// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:analyzer/source/source_range.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

import '../../../generated/parser_test_base.dart';
import '../resolution/context_collection_resolution.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(CompilationUnitImplTest);
    defineReflectiveTests(EvaluateExpressionTest);
    defineReflectiveTests(ExpressionImplTest);
    defineReflectiveTests(InstanceCreationExpressionImplTest);
    defineReflectiveTests(IntegerLiteralImplTest);
    defineReflectiveTests(NodeCoveringTest);
  });
}

@reflectiveTest
class CompilationUnitImplTest extends ParserTestCase {
  late final String testSource;
  late final CompilationUnitImpl testUnit;

  parse(String source) {
    testSource = source;
    testUnit = parseCompilationUnit(source) as CompilationUnitImpl;
  }

  test_languageVersionComment_afterScriptTag() {
    parse('''
#!/bin/false
// @dart=2.9
void main() {}
''');
    var token = testUnit.languageVersionToken!;
    expect(token.major, 2);
    expect(token.minor, 9);
    expect(token.offset, 13);
  }

  test_languageVersionComment_afterScriptTag_andComment() {
    parse('''
#!/bin/false
// A normal comment.
// @dart=2.9
void main() {}
''');
    var token = testUnit.languageVersionToken!;
    expect(token.major, 2);
    expect(token.minor, 9);
    expect(token.offset, 34);
  }

  test_languageVersionComment_firstComment() {
    parse('''
// @dart=2.6
void main() {}
''');
    expect(
      testUnit.languageVersionToken,
      testUnit.beginToken.precedingComments,
    );
  }

  test_languageVersionComment_none() {
    parse('''
void main() {}
''');
    expect(testUnit.languageVersionToken, null);
  }

  test_languageVersionComment_none_onlyNormalComment() {
    parse('''
// A normal comment.
void main() {}
''');
    expect(testUnit.languageVersionToken, null);
  }

  test_languageVersionComment_secondComment() {
    parse('''
// A normal comment.
// @dart=2.6
void main() {}
''');
    expect(
      testUnit.languageVersionToken,
      testUnit.beginToken.precedingComments!.next,
    );
  }

  test_languageVersionComment_thirdComment() {
    parse('''
// A normal comment.
// Another normal comment.
// @dart=2.6
void main() {}
''');
    expect(
      testUnit.languageVersionToken,
      testUnit.beginToken.precedingComments!.next!.next,
    );
  }
}

@reflectiveTest
class EvaluateExpressionTest extends PubPackageResolutionTest {
  test_hasError_listLiteral_forElement() async {
    await resolveTestCode('''
var x = const [for (var i = 0; i < 4; i++) i];
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isNotEmpty);
    expect(result.value, isNull);
  }

  test_hasError_mapLiteral_forElement() async {
    await resolveTestCode('''
var x = const {for (var i = 0; i < 4; i++) i: 0};
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result?.diagnostics, isNotEmpty);
    expect(result?.value, isNull);
  }

  test_hasError_methodInvocation() async {
    await resolveTestCode('''
var x = 42.abs();
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isNotEmpty);
    expect(result.value, isNull);
  }

  test_hasError_setLiteral_forElement() async {
    await resolveTestCode('''
var x = const {for (var i = 0; i < 4; i++) i};
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isNotEmpty);
    expect(result.value, isNull);
  }

  test_hasValue_binaryExpression() async {
    await resolveTestCode('''
var x = 1 + 2;
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isEmpty);
    expect(result.value!.toIntValue(), 3);
  }

  test_hasValue_constantReference() async {
    await resolveTestCode('''
const a = 42;
var x = a;
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isEmpty);
    expect(result.value!.toIntValue(), 42);
  }

  test_hasValue_constantReference_imported() async {
    newFile('$testPackageLibPath/a.dart', r'''
const a = 42;
''');
    await resolveTestCode('''
import 'a.dart';
var x = a;
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isEmpty);
    expect(result.value!.toIntValue(), 42);
  }

  test_hasValue_intLiteral() async {
    await resolveTestCode('''
var x = 42;
''');
    var result = _evaluateX();
    expect(result, isNotNull);
    expect(result!.diagnostics, isEmpty);
    expect(result.value!.toIntValue(), 42);
  }

  test_nonConstant() async {
    await resolveTestCode('''
var a = 42;
var x = a;
''');
    var result = _evaluateX();
    expect(result, isNull);
  }

  AttemptedConstantEvaluationResult? _evaluateX() {
    var node = findNode.topVariableDeclarationByName('x').initializer!;
    return node.computeConstantValue();
  }
}

@reflectiveTest
class ExpressionImplTest extends ParserTestCase {
  late final String testSource;
  late final CompilationUnitImpl testUnit;

  assertInContext(String snippet, bool isInContext) {
    int index = testSource.indexOf(snippet);
    expect(index >= 0, isTrue);
    var node = testUnit.nodeCovering(offset: index)! as AstNodeImpl;
    expect(node, TypeMatcher<ExpressionImpl>());
    expect(
      (node as ExpressionImpl).inConstantContext,
      isInContext ? isTrue : isFalse,
    );
  }

  parse(String source) {
    testSource = source;
    testUnit = parseCompilationUnit(source) as CompilationUnitImpl;
  }

  test_inConstantContext_enumConstant_true() {
    parse('''
enum E {
  v([]);
  const E(_);
}
''');
    assertInContext('[]', true);
  }

  test_inConstantContext_instanceCreation_annotation_true() {
    parse('''
@C(C(0))
class C {
  const C(_);
}
''');
    assertInContext("C(0", true);
  }

  test_inConstantContext_instanceCreation_fieldWithConstConstructor() {
    parse('''
class C {
  final d = D();
  const C();
}
class D {
  const D();
}
''');
    assertInContext("D()", false);
  }

  test_inConstantContext_instanceCreation_fieldWithoutConstConstructor() {
    parse('''
class C {
  final d = D();
  C();
}
class D {
  const D();
}
''');
    assertInContext("D()", false);
  }

  test_inConstantContext_instanceCreation_functionLiteral() {
    parse('''
const V = () => C();
class C {
  const C();
}
''');
    assertInContext("C()", false);
  }

  test_inConstantContext_instanceCreation_instanceCreation_false() {
    parse('''
f() {
  return new C(C());
}
class C {
  const C(_);
}
''');
    assertInContext("C())", false);
  }

  test_inConstantContext_instanceCreation_instanceCreation_true() {
    parse('''
f() {
  return new C(C());
}
class C {
  const C(_);
}
''');
    assertInContext("C())", false);
  }

  test_inConstantContext_instanceCreation_listLiteral_false() {
    parse('''
f() {
  return [C()];
}
class C {
  const C();
}
''');
    assertInContext("C()]", false);
  }

  test_inConstantContext_instanceCreation_listLiteral_true() {
    parse('''
f() {
  return const [C()];
}
class C {
  const C();
}
''');
    assertInContext("C()]", true);
  }

  test_inConstantContext_instanceCreation_mapLiteral_false() {
    parse('''
f() {
  return {'a' : C()};
}
class C {
  const C();
}
''');
    assertInContext("C()}", false);
  }

  test_inConstantContext_instanceCreation_mapLiteral_true() {
    parse('''
f() {
  return const {'a' : C()};
}
class C {
  const C();
}
''');
    assertInContext("C()}", true);
  }

  test_inConstantContext_instanceCreation_nestedListLiteral_false() {
    parse('''
f() {
  return [[''], [C()]];
}
class C {
  const C();
}
''');
    assertInContext("C()]", false);
  }

  test_inConstantContext_instanceCreation_nestedListLiteral_true() {
    parse('''
f() {
  return const [[''], [C()]];
}
class C {
  const C();
}
''');
    assertInContext("C()]", true);
  }

  test_inConstantContext_instanceCreation_nestedMapLiteral_false() {
    parse('''
f() {
  return {'a' : {C() : C()}};
}
class C {
  const C();
}
''');
    assertInContext("C() :", false);
    assertInContext("C()}", false);
  }

  test_inConstantContext_instanceCreation_nestedMapLiteral_true() {
    parse('''
f() {
  return const {'a' : {C() : C()}};
}
class C {
  const C();
}
''');
    assertInContext("C() :", true);
    assertInContext("C()}", true);
  }

  test_inConstantContext_instanceCreation_switch_true() {
    parse('''
f(v) {
  switch (v) {
  case const C():
    break;
  }
}
class C {
  const C();
}
''');
    assertInContext("C()", true);
  }

  @failingTest
  test_inConstantContext_instanceCreation_switch_true_language219() {
    // Expected: true
    //   Actual: <false>
    parse('''
// @dart = 2.19
f(v) {
  switch (v) {
  case C():
    break;
  }
}
class C {
  const C();
}
''');
    assertInContext("C()", true);
  }

  test_inConstantContext_instanceCreation_topLevelVariable_false() {
    parse('''
var c = C();
class C {
  const C();
}
''');
    assertInContext("C()", false);
  }

  test_inConstantContext_instanceCreation_topLevelVariable_true() {
    parse('''
const c = C();
class C {
  const C();
}
''');
    assertInContext("C()", true);
  }

  test_inConstantContext_listLiteral_annotation_true() {
    parse('''
@C([])
class C {
  const C(_);
}
''');
    assertInContext("[]", true);
  }

  test_inConstantContext_listLiteral_functionLiteral() {
    parse('''
const V = () => [];
class C {
  const C();
}
''');
    assertInContext("[]", false);
  }

  test_inConstantContext_listLiteral_initializer_false() {
    parse('''
var c = [];
''');
    assertInContext("[]", false);
  }

  test_inConstantContext_listLiteral_initializer_true() {
    parse('''
const c = [];
''');
    assertInContext("[]", true);
  }

  test_inConstantContext_listLiteral_instanceCreation_false() {
    parse('''
f() {
  return new C([]);
}
class C {
  const C(_);
}
''');
    assertInContext("[]", false);
  }

  test_inConstantContext_listLiteral_instanceCreation_true() {
    parse('''
f() {
  return const C([]);
}
class C {
  const C(_);
}
''');
    assertInContext("[]", true);
  }

  test_inConstantContext_listLiteral_listLiteral_false() {
    parse('''
f() {
  return [[''], []];
}
''');
    assertInContext("['']", false);
    assertInContext("[]", false);
  }

  test_inConstantContext_listLiteral_listLiteral_true() {
    parse('''
f() {
  return const [[''], []];
}
''');
    assertInContext("['']", true);
    assertInContext("[]", true);
  }

  test_inConstantContext_listLiteral_mapLiteral_false() {
    parse('''
f() {
  return {'a' : [''], 'b' : []};
}
''');
    assertInContext("['']", false);
    assertInContext("[]", false);
  }

  test_inConstantContext_listLiteral_mapLiteral_true() {
    parse('''
f() {
  return const {'a' : [''], 'b' : []};
}
''');
    assertInContext("['']", true);
    assertInContext("[]", true);
  }

  test_inConstantContext_listLiteral_namedFields_recordLiteral_false() {
    parse('''
final x = (0, foo: [1]);
''');
    assertInContext('[1]', false);
  }

  test_inConstantContext_listLiteral_namedFields_recordLiteral_true() {
    parse('''
final x = const (0, foo: [1]);
''');
    assertInContext('[1]', true);
  }

  test_inConstantContext_listLiteral_positionalFields_recordLiteral_false() {
    parse('''
final x = (0, [1]);
''');
    assertInContext('[1]', false);
  }

  test_inConstantContext_listLiteral_positionalFields_recordLiteral_true() {
    parse('''
final x = const (0, [1]);
''');
    assertInContext('[1]', true);
  }

  test_inConstantContext_listLiteral_switch_true() {
    parse('''
f(v) {
  switch (v) {
  case const []:
    break;
  }
}
''');
    assertInContext("[]", true);
  }

  @failingTest
  test_inConstantContext_listLiteral_switch_true_language219() {
    // Expected: <Instance of 'ExpressionImpl'>
    //   Actual: ListPatternImpl:<[]>
    //    Which: is not an instance of 'ExpressionImpl'
    parse('''
// @dart = 2.19
f(v) {
  switch (v) {
  case []:
    break;
  }
}
''');
    assertInContext("[]", true);
  }

  test_inConstantContext_mapLiteral_annotation_true() {
    parse('''
@C({})
class C {
  const C(_);
}
''');
    assertInContext("{}", true);
  }

  test_inConstantContext_mapLiteral_functionLiteral() {
    parse('''
const V = () => {};
class C {
  const C();
}
''');
    assertInContext("{}", false);
  }

  test_inConstantContext_mapLiteral_initializer_false() {
    parse('''
var c = {};
''');
    assertInContext("{}", false);
  }

  test_inConstantContext_mapLiteral_initializer_true() {
    parse('''
const c = {};
''');
    assertInContext("{}", true);
  }

  test_inConstantContext_mapLiteral_instanceCreation_false() {
    parse('''
f() {
  return new C({});
}
class C {
  const C(_);
}
''');
    assertInContext("{}", false);
  }

  test_inConstantContext_mapLiteral_instanceCreation_true() {
    parse('''
f() {
  return const C({});
}
class C {
  const C(_);
}
''');
    assertInContext("{}", true);
  }

  test_inConstantContext_mapLiteral_listLiteral_false() {
    parse('''
f() {
  return [{'a' : 1}, {'b' : 2}];
}
''');
    assertInContext("{'a", false);
    assertInContext("{'b", false);
  }

  test_inConstantContext_mapLiteral_listLiteral_true() {
    parse('''
f() {
  return const [{'a' : 1}, {'b' : 2}];
}
''');
    assertInContext("{'a", true);
    assertInContext("{'b", true);
  }

  test_inConstantContext_mapLiteral_mapLiteral_false() {
    parse('''
f() {
  return {'a' : {'b' : 0}, 'c' : {'d' : 1}};
}
''');
    assertInContext("{'b", false);
    assertInContext("{'d", false);
  }

  test_inConstantContext_mapLiteral_mapLiteral_true() {
    parse('''
f() {
  return const {'a' : {'b' : 0}, 'c' : {'d' : 1}};
}
''');
    assertInContext("{'b", true);
    assertInContext("{'d", true);
  }

  test_inConstantContext_mapLiteral_switch_true() {
    parse('''
f(v) {
  switch (v) {
  case const {}:
    break;
  }
}
''');
    assertInContext("{}", true);
  }

  @failingTest
  test_inConstantContext_mapLiteral_switch_true_language219() {
    // Expected: <Instance of 'ExpressionImpl'>
    //   Actual: MapPatternImpl:<{}>
    //    Which: is not an instance of 'ExpressionImpl'
    parse('''
// @dart = 2.19
f(v) {
  switch (v) {
  case {}:
    break;
  }
}
''');
    assertInContext("{}", true);
  }

  test_inConstantContext_recordLiteral_listLiteral_false() {
    parse('''
final x = [0, (1, 2)];
''');
    assertInContext('(1, 2)', false);
  }

  test_inConstantContext_recordLiteral_listLiteral_true() {
    parse('''
final x = const [0, (1, 2)];
''');
    assertInContext('(1, 2)', true);
  }

  test_inConstantContext_recordLiteral_namedFields_recordLiteral_false() {
    parse('''
final x = (0, foo: (1, 2));
''');
    assertInContext('(1, 2)', false);
  }

  test_inConstantContext_recordLiteral_namedFields_recordLiteral_true() {
    parse('''
final x = const (0, foo: (1, 2));
''');
    assertInContext('(1, 2)', true);
  }

  test_inConstantContext_recordLiteral_positionalFields_recordLiteral_false() {
    parse('''
final x = (0, (1, 2));
''');
    assertInContext('(1, 2)', false);
  }

  test_inConstantContext_recordLiteral_positionalFields_recordLiteral_true() {
    parse('''
final x = const (0, (1, 2));
''');
    assertInContext('(1, 2)', true);
  }
}

@reflectiveTest
class InstanceCreationExpressionImplTest extends PubPackageResolutionTest {
  assertIsConst(String search, bool expectedResult) {
    var node = findNode.instanceCreation(search);
    expect((node as InstanceCreationExpressionImpl).isConst, expectedResult);
  }

  test_isConst_notInContext_constructor_const_constParam_identifier() async {
    await resolveTestCode('''
var v = C(C.a);
class C {
  static const C a = C.c();
  const C(c);
  const C.c();
}
''');
    assertIsConst("C(C", false);
  }

  test_isConst_notInContext_constructor_const_constParam_named() async {
    await resolveTestCode('''
var v = C(c: C());
class C {
  const C({c});
}
''');
    assertIsConst("C(c", false);
  }

  test_isConst_notInContext_constructor_const_constParam_named_parens() async {
    await resolveTestCode('''
var v = C(c: (C()));
class C {
  const C({c});
}
''');
    assertIsConst("C(c", false);
  }

  test_isConst_notInContext_constructor_const_constParam_parens() async {
    await resolveTestCode('''
var v = C( (C.c()) );
class C {
  const C(c);
  const C.c();
}
''');
    assertIsConst("C( (", false);
  }

  test_isConst_notInContext_constructor_const_generic_named() async {
    await resolveTestCode('''
f() => <Object>[C<int>.n()];
class C<E> {
  const C.n();
}
''');
    assertIsConst("C<int>.n", false);
  }

  test_isConst_notInContext_constructor_const_generic_named_prefixed() async {
    newFile('$testPackageLibPath/c.dart', '''
class C<E> {
  const C.n();
}
''');
    await resolveTestCode('''
import 'c.dart' as p;
f() => <Object>[p.C<int>.n()];
''');
    assertIsConst("C<int>", false);
  }

  test_isConst_notInContext_constructor_const_generic_unnamed() async {
    await resolveTestCode('''
f() => <Object>[C<int>()];
class C<E> {
  const C();
}
''');
    assertIsConst("C<int>", false);
  }

  test_isConst_notInContext_constructor_const_generic_unnamed_prefixed() async {
    newFile('$testPackageLibPath/c.dart', '''
class C<E> {
  const C();
}
''');
    await resolveTestCode('''
import 'c.dart' as p;
f() => <Object>[p.C<int>()];
''');
    assertIsConst("C<int>", false);
  }

  test_isConst_notInContext_constructor_const_nonConstParam_constructor() async {
    await resolveTestCode('''
f() {
  return A(B());
}

class A {
  const A(B b);
}

class B {
  B();
}
''');
    assertIsConst("B())", false);
  }

  test_isConst_notInContext_constructor_const_nonConstParam_variable() async {
    await resolveTestCode('''
f(int i) => <Object>[C(i)];
class C {
  final int f;
  const C(this.f);
}
''');
    assertIsConst("C(i)", false);
  }

  test_isConst_notInContext_constructor_const_nonGeneric_named() async {
    await resolveTestCode('''
f() => <Object>[C.n()];
class C<E> {
  const C.n();
}
''');
    assertIsConst("C.n()]", false);
  }

  test_isConst_notInContext_constructor_const_nonGeneric_named_prefixed() async {
    newFile('$testPackageLibPath/c.dart', '''
class C {
  const C.n();
}
''');
    await resolveTestCode('''
import 'c.dart' as p;
f() => <Object>[p.C.n()];
''');
    assertIsConst("C.n()", false);
  }

  test_isConst_notInContext_constructor_const_nonGeneric_unnamed() async {
    await resolveTestCode('''
f() => <Object>[C()];
class C {
  const C();
}
''');
    assertIsConst("C()]", false);
  }

  test_isConst_notInContext_constructor_const_nonGeneric_unnamed_prefixed() async {
    newFile('$testPackageLibPath/c.dart', '''
class C {
  const C();
}
''');
    await resolveTestCode('''
import 'c.dart' as p;
f() => <Object>[p.C()];
''');
    assertIsConst("C()", false);
  }

  test_isConst_notInContext_constructor_nonConst() async {
    await resolveTestCode('''
f() => <Object>[C()];
class C {
  C();
}
''');
    assertIsConst("C()]", false);
  }
}

@reflectiveTest
class IntegerLiteralImplTest {
  test_isValidAsDouble_dec_1024Bits() {
    expect(
      IntegerLiteralImpl.isValidAsDouble(
        '179769313486231570814527423731704356798070567525844996598917476803'
        '157260780028538760589558632766878171540458953514382464234321326889'
        '464182768467546703537516986049910576551282076245490090389328944075'
        '868508455133942304583236903222948165808559332123348274797826204144'
        '723168738177180919299881250404026184124858369',
      ),
      false,
    );
  }

  test_isValidAsDouble_dec_11ExponentBits() {
    expect(
      IntegerLiteralImpl.isValidAsDouble(
        '359538626972463141629054847463408713596141135051689993197834953606'
        '314521560057077521179117265533756343080917907028764928468642653778'
        '928365536935093407075033972099821153102564152490980180778657888151'
        '737016910267884609166473806445896331617118664246696549595652408289'
        '446337476354361838599762500808052368249716736',
      ),
      false,
    );
  }

  test_isValidAsDouble_dec_16CharValue() {
    // 16 characters is used as a cutoff point for optimization
    expect(IntegerLiteralImpl.isValidAsDouble('9007199254740991'), true);
  }

  test_isValidAsDouble_dec_53BitsMax() {
    expect(
      IntegerLiteralImpl.isValidAsDouble(
        '179769313486231570814527423731704356798070567525844996598917476803'
        '157260780028538760589558632766878171540458953514382464234321326889'
        '464182768467546703537516986049910576551282076245490090389328944075'
        '868508455133942304583236903222948165808559332123348274797826204144'
        '723168738177180919299881250404026184124858368',
      ),
      true,
    );
  }

  test_isValidAsDouble_dec_54BitsMax() {
    expect(IntegerLiteralImpl.isValidAsDouble('18014398509481983'), false);
  }

  test_isValidAsDouble_dec_54BitsMin() {
    expect(IntegerLiteralImpl.isValidAsDouble('9007199254740993'), false);
  }

  test_isValidAsDouble_dec_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsDouble('45'), true);
  }

  test_isValidAsDouble_dec_largest15CharValue() {
    // 16 characters is used as a cutoff point for optimization
    expect(IntegerLiteralImpl.isValidAsDouble('999999999999999'), true);
  }

  test_isValidAsDouble_hex_1024Bits() {
    expect(
      IntegerLiteralImpl.isValidAsDouble(
        '0xFFFFFFFFFFFFF800000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000001',
      ),
      false,
    );
  }

  test_isValidAsDouble_hex_11ExponentBits() {
    expect(
      IntegerLiteralImpl.isValidAsDouble(
        '0x1FFFFFFFFFFFFF00000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000000000'
        '0000000000000000000000000000000000000000000000000000000000000',
      ),
      false,
    );
  }

  test_isValidAsDouble_hex_16CharValue() {
    // 16 characters is used as a cutoff point for optimization
    expect(IntegerLiteralImpl.isValidAsDouble('0x0FFFFFFFFFFFFF'), true);
  }

  test_isValidAsDouble_hex_53BitsMax() {
    expect(
      IntegerLiteralImpl.isValidAsDouble(
        '0xFFFFFFFFFFFFF800000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000000000'
        '000000000000000000000000000000000000000000000000000000000000',
      ),
      true,
    );
  }

  test_isValidAsDouble_hex_54BitsMax() {
    expect(IntegerLiteralImpl.isValidAsDouble('0x3FFFFFFFFFFFFF'), false);
  }

  test_isValidAsDouble_hex_54BitsMin() {
    expect(IntegerLiteralImpl.isValidAsDouble('0x20000000000001'), false);
  }

  test_isValidAsDouble_hex_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsDouble('0x45'), true);
  }

  test_isValidAsDouble_hex_largest15CharValue() {
    // 16 characters is used as a cutoff point for optimization
    expect(IntegerLiteralImpl.isValidAsDouble('0xFFFFFFFFFFFFF'), true);
  }

  test_isValidAsInteger_dec_negative_equalMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('9223372036854775808', true),
      true,
    );
  }

  test_isValidAsInteger_dec_negative_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsInteger('24', true), true);
  }

  test_isValidAsInteger_dec_negative_leadingZeros_overMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('009923372036854775807', true),
      false,
    );
  }

  test_isValidAsInteger_dec_negative_leadingZeros_underMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('004223372036854775807', true),
      true,
    );
  }

  test_isValidAsInteger_dec_negative_oneOverMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('9223372036854775809', true),
      false,
    );
  }

  test_isValidAsInteger_dec_negative_tooManyDigits() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('10223372036854775808', true),
      false,
    );
  }

  test_isValidAsInteger_dec_positive_equalMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('9223372036854775807', false),
      true,
    );
  }

  test_isValidAsInteger_dec_positive_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsInteger('42', false), true);
  }

  test_isValidAsInteger_dec_positive_leadingZeros_overMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('009923372036854775807', false),
      false,
    );
  }

  test_isValidAsInteger_dec_positive_leadingZeros_underMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('004223372036854775807', false),
      true,
    );
  }

  test_isValidAsInteger_dec_positive_oneOverMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('9223372036854775808', false),
      false,
    );
  }

  test_isValidAsInteger_dec_positive_tooManyDigits() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('10223372036854775808', false),
      false,
    );
  }

  test_isValidAsInteger_heX_negative_equalMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X8000000000000000', true),
      true,
    );
  }

  test_isValidAsInteger_hex_negative_equalMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x8000000000000000', true),
      true,
    );
  }

  test_isValidAsInteger_heX_negative_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsInteger('0XFF', true), true);
  }

  test_isValidAsInteger_hex_negative_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsInteger('0xFF', true), true);
  }

  test_isValidAsInteger_heX_negative_leadingZeros_overMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X00FFFFFFFFFFFFFFFFF', true),
      false,
    );
  }

  test_isValidAsInteger_hex_negative_leadingZeros_overMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x00FFFFFFFFFFFFFFFFF', true),
      false,
    );
  }

  test_isValidAsInteger_heX_negative_leadingZeros_underMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X007FFFFFFFFFFFFFFF', true),
      true,
    );
  }

  test_isValidAsInteger_hex_negative_leadingZeros_underMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x007FFFFFFFFFFFFFFF', true),
      true,
    );
  }

  test_isValidAsInteger_heX_negative_oneBelowMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X7FFFFFFFFFFFFFFF', true),
      true,
    );
  }

  test_isValidAsInteger_hex_negative_oneBelowMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x7FFFFFFFFFFFFFFF', true),
      true,
    );
  }

  test_isValidAsInteger_heX_negative_oneOverMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X8000000000000001', true),
      false,
    );
  }

  test_isValidAsInteger_hex_negative_oneOverMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x8000000000000001', true),
      false,
    );
  }

  test_isValidAsInteger_heX_negative_tooManyDigits() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X10000000000000000', true),
      false,
    );
  }

  test_isValidAsInteger_hex_negative_tooManyDigits() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x10000000000000000', true),
      false,
    );
  }

  test_isValidAsInteger_heX_positive_equalMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X7FFFFFFFFFFFFFFF', false),
      true,
    );
  }

  test_isValidAsInteger_hex_positive_equalMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x7FFFFFFFFFFFFFFF', false),
      true,
    );
  }

  test_isValidAsInteger_heX_positive_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsInteger('0XFF', false), true);
  }

  test_isValidAsInteger_hex_positive_fewDigits() {
    expect(IntegerLiteralImpl.isValidAsInteger('0xFF', false), true);
  }

  test_isValidAsInteger_heX_positive_leadingZeros_overMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X00FFFFFFFFFFFFFFFFF', false),
      false,
    );
  }

  test_isValidAsInteger_hex_positive_leadingZeros_overMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x00FFFFFFFFFFFFFFFFF', false),
      false,
    );
  }

  test_isValidAsInteger_heX_positive_leadingZeros_underMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X007FFFFFFFFFFFFFFF', false),
      true,
    );
  }

  test_isValidAsInteger_hex_positive_leadingZeros_underMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x007FFFFFFFFFFFFFFF', false),
      true,
    );
  }

  test_isValidAsInteger_heX_positive_oneOverMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0X10000000000000000', false),
      false,
    );
  }

  test_isValidAsInteger_hex_positive_oneOverMax() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0x10000000000000000', false),
      false,
    );
  }

  test_isValidAsInteger_heX_positive_tooManyDigits() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0XFF0000000000000000', false),
      false,
    );
  }

  test_isValidAsInteger_hex_positive_tooManyDigits() {
    expect(
      IntegerLiteralImpl.isValidAsInteger('0xFF0000000000000000', false),
      false,
    );
  }
}

@reflectiveTest
class NodeCoveringTest extends PubPackageResolutionTest {
  Future<AstNode> coveringNode(String sourceCode) async {
    var range = await _range(sourceCode);
    var node = result.unit.nodeCovering(
      offset: range.offset,
      length: range.length,
    );
    return node!;
  }

  void test_after_EOF() async {
    await resolveTestCode('''
library myLib;
''');
    var node = result.unit.nodeCovering(offset: 100, length: 20);
    expect(node, null);
  }

  Future<void> test_after_lastNonEOF() async {
    var node = await coveringNode('''
library myLib;

^
''');
    node as CompilationUnit;
  }

  Future<void> test_atBOF_atClass() async {
    var node = await coveringNode('''
^class A {}
''');
    node as ClassDeclaration;
  }

  Future<void> test_atBOF_atComment() async {
    var node = await coveringNode('''
^// comment
class A {}
''');
    node as CompilationUnit;
  }

  Future<void> test_atCommentEnd() async {
    var node = await coveringNode('''
/// ^
class A {}
''');
    node as Comment;
  }

  Future<void> test_atEOF() async {
    var node = await coveringNode('''
library myLib;

^''');
    node as CompilationUnit;
  }

  Future<void> test_before_firstNonEOF() async {
    var node = await coveringNode('''
^

library myLib;
''');
    node as CompilationUnit;
  }

  Future<void> test_between_arrowAndIdentifier() async {
    var node = await coveringNode('''
void f(int i) {
  return switch (i) {
    1 =>^g();
    _ => 0;
  }
}
int g() => 0;
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_classMembers() async {
    var node = await coveringNode('''
class C {
  void a() {}
^
  void b() {}
}
''');
    node as ClassBody;
  }

  Future<void> test_between_colonAndIdentifier_namedExpression() async {
    var node = await coveringNode('''
void f(int i) {
  g(a:^i)
}
void g({required int a}) {}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_colonAndIdentifier_switchCase() async {
    var node = await coveringNode('''
void f(int i) {
  switch (i) {
    case 1:^g();
  }
}
void g() {}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_commaAndComma_arguments_synthetic() async {
    var node = await coveringNode('''
void f(int a, int b, int c) {
  f(a,^,c);
}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_commaAndIdentifier_arguments() async {
    var node = await coveringNode('''
void f(int a, int b) {
  f(a,^b);
}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_commaAndIdentifier_parameters() async {
    var node = await coveringNode('''
class C {
  void m(int a,^int b) {}
}
''');
    node as NamedType;
  }

  Future<void> test_between_commaAndIdentifier_typeArguments() async {
    var node = await coveringNode('''
var m = Map<int,^int>();
''');
    node as NamedType;
  }

  Future<void> test_between_commaAndIdentifier_typeParameters() async {
    var node = await coveringNode('''
class C<S,^T> {}
''');
    node as TypeParameter;
  }

  Future<void> test_between_declarations() async {
    var node = await coveringNode('''
class A {}
^
class B {}
''');
    node as CompilationUnit;
  }

  Future<void> test_between_directives() async {
    var node = await coveringNode('''
library myLib;
^
import 'dart:core';
''');
    node as CompilationUnit;
  }

  Future<void> test_between_identifierAndArgumentList() async {
    var node = await coveringNode('''
void f(C c) {
  c.m^();
}
class C {
  void m() {}
}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_identifierAndArgumentList_synthetic() async {
    var node = await coveringNode('''
void f(C c) {
  c.^();
}
class C {
  void m() {}
}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_identifierAndComma_arguments() async {
    var node = await coveringNode('''
void f(int a, int b) {
  f(a^, b);
}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_identifierAndComma_parameters() async {
    var node = await coveringNode('''
class C {
  void m(int a^, int b) {}
}
''');
    node as SimpleFormalParameter;
  }

  Future<void> test_between_identifierAndComma_typeArguments() async {
    var node = await coveringNode('''
var m = Map<int^, int>();
''');
    node as NamedType;
  }

  Future<void> test_between_identifierAndComma_typeParameters() async {
    var node = await coveringNode('''
class C<S^, T> {}
''');
    node as TypeParameter;
  }

  Future<void> test_between_identifierAndParameterList() async {
    var node = await coveringNode('''
void f^() {}
''');
    node as FunctionDeclaration;
  }

  Future<void> test_between_identifierAndPeriod() async {
    var node = await coveringNode('''
var x = o^.m();
''');
    node as SimpleIdentifier;
  }

  Future<void>
  test_between_identifierAndTypeArgumentList_methodInvocation() async {
    var node = await coveringNode('''
void f(C c) {
  c.m^<int>();
}
class C {
  void m<T>() {}
}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_identifierAndTypeParameterList() async {
    var node = await coveringNode('''
class C^<T> {}
''');
    node as NameWithTypeParameters;
  }

  Future<void> test_between_modifierAndFunctionBody() async {
    var node = await coveringNode('''
void f() async^{}
''');
    node as BlockFunctionBody;
  }

  Future<void> test_between_nameAndParameters_function() async {
    var node = await coveringNode('''
void f^() {}
''');
    node as FunctionDeclaration;
  }

  Future<void> test_between_nameAndParameters_method() async {
    var node = await coveringNode('''
class C {
  void m^() {}
}
''');
    node as MethodDeclaration;
  }

  Future<void> test_between_periodAndIdentifier() async {
    var node = await coveringNode('''
var x = o.^m();
''');
    node as SimpleIdentifier;
  }

  Future<void> test_between_statements() async {
    var node = await coveringNode('''
void f() {
  var x = 0;
^
  print(x);
}
''');
    node as Block;
  }

  Future<void> test_inComment_beginning() async {
    var node = await coveringNode('''
/// A [^B].
class C {}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_inComment_beginning_qualified() async {
    var node = await coveringNode('''
/// A [B.^b].
class C {}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_inComment_end() async {
    var node = await coveringNode('''
/// A [B.b^].
class C {}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_inComment_middle() async {
    var node = await coveringNode('''
/// A [B.b^b].
class C {}
''');
    node as SimpleIdentifier;
  }

  Future<void> test_inName_class() async {
    var node = await coveringNode('''
class A^B {}
''');
    node as NameWithTypeParameters;
  }

  Future<void> test_inName_function() async {
    var node = await coveringNode('''
void f^f() {}
''');
    node as FunctionDeclaration;
  }

  Future<void> test_inName_method() async {
    var node = await coveringNode('''
class C {
  void m^m() {}
}
''');
    node as MethodDeclaration;
  }

  Future<void> test_inOperator_assignment() async {
    var node = await coveringNode('''
void f(int x) {
  x +^= 3;
}
''');
    node as AssignmentExpression;
  }

  Future<void> test_inOperator_nullAwareAccess() async {
    var node = await coveringNode('''
var x = o?^.m();
''');
    node as MethodInvocation;
  }

  Future<void> test_inOperator_postfix() async {
    var node = await coveringNode('''
var x = y+^+;
''');
    node as PostfixExpression;
  }

  Future<void> test_libraryKeyword() async {
    var node = await coveringNode('''
libr^ary myLib;
''');
    node as LibraryDirective;
  }

  Future<void> test_parentAndChildWithSameRange_blockFunctionBody() async {
    var node = await coveringNode('''
void f() { ^ }
''');
    node as Block;
    var parent = node.parent;
    parent as BlockFunctionBody;
    expect(parent.offset, node.offset);
    expect(parent.length, node.length);
  }

  Future<void> test_parentAndChildWithSameRange_implicitCall() async {
    var node = await coveringNode('''
class C { void call() {} }  Function f = C^();
''');
    node as NamedType;
  }

  Future<SourceRange> _range(String sourceCode) async {
    // TODO(brianwilkerson): Move TestCode to the analyzer package and make use
    //  of it here.
    var offset = sourceCode.indexOf('^');
    if (offset < 0 || sourceCode.contains('^', offset + 1)) {
      fail('Tests must contain a single selection range');
    }
    var testCode =
        sourceCode.substring(0, offset) + sourceCode.substring(offset + 1);
    await resolveTestCode(testCode);
    return SourceRange(offset, 0);
  }
}
