pkg/linter/test/rules/avoid_init_to_null_test.dart

// Copyright (c) 2021, 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/src/diagnostic/diagnostic.dart' as diag;
import 'package:test_reflective_loader/test_reflective_loader.dart';

import '../rule_test_support.dart';

void main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(AvoidInitToNullTest);
    defineReflectiveTests(AvoidInitToNullSuperFormalsTest);
  });
}

@reflectiveTest
class AvoidInitToNullSuperFormalsTest extends LintRuleTest {
  @override
  String get lintRule => LintNames.avoid_init_to_null;

  test_forLoop() async {
    await assertDiagnosticsFromMarkup(r'''
void f() {
  for (var [!i = null!]; i != null; i++) {
  }
}
''');
  }

  test_nullableStringInit() async {
    await assertDiagnosticsFromMarkup(r'''
class A {
  String? a;
  A({[!this.a = null!]});
}
''');
  }

  test_superInit_2() async {
    await assertDiagnosticsFromMarkup(r'''
class A {
  String? a;
  A({/*[0*/this.a = null/*0]*/});
}
class B extends A {
  B({/*[1*/super.a = null/*1]*/});
}
''');
  }

  /// https://github.com/dart-lang/linter/issues/3349
  test_superInit_nolint() async {
    await assertNoDiagnostics(r'''
class A {
  String? a;
  A({this.a = ''});
}

class B extends A {
  B({super.a = null});
}
''');
  }
}

@reflectiveTest
class AvoidInitToNullTest extends LintRuleTest {
  // TODO(pq): mock and add FutureOr examples

  @override
  String get lintRule => LintNames.avoid_init_to_null;

  test_fieldFormalParameter_inferredType() async {
    await assertDiagnosticsFromMarkup(r'''
class C {
  int? i;
  C({[!this.i = null!]});
}
''');
  }

  test_instanceField_inferredType_final() async {
    await assertNoDiagnostics(r'''
class C {
  final i = null;
}
''');
  }

  test_instanceField_intType_noInitializer() async {
    await assertNoDiagnostics(r'''
class C {
  int i;
  C(): i = 1;
}
''');
  }

  test_instanceField_nullableIntType() async {
    await assertDiagnosticsFromMarkup(r'''
class C {
  int? [!i = null!];
  C(): i = 1;
}
''');
  }

  test_invalidAssignment_field() async {
    await assertDiagnostics(
      r'''
class X {
  int x = null;
}
''',
      [
        // No lint
        error(diag.invalidAssignment, 20, 4),
      ],
    );
  }

  test_invalidAssignment_namedParameter() async {
    await assertDiagnostics(
      r'''
class X {
  X({int a = null});
}
''',
      [
        // No lint
        error(diag.invalidAssignment, 23, 4),
      ],
    );
  }

  test_invalidAssignment_namedParameter_fieldFormal() async {
    await assertDiagnostics(
      r'''
class X {
  int x;
  X({this.x = null});
}
''',
      [
        // No lint
        error(diag.invalidAssignment, 33, 4),
      ],
    );
  }

  test_invalidAssignment_topLevelVariable() async {
    await assertDiagnostics(
      r'''
int i = null;
''',
      [
        // No lint
        error(diag.invalidAssignment, 8, 4),
      ],
    );
  }

  test_namedParameter_inferredType() async {
    await assertDiagnosticsFromMarkup(r'''
foo({[!p = null!]}) {}
''');
  }

  test_namedParameter_inferredType_defaultValueIsInt() async {
    await assertNoDiagnostics(r'''
foo({p = 1}) {}
''');
  }

  test_namedParameter_inferredType_noDefaultValue() async {
    await assertNoDiagnostics(r'''
foo({p}) {}
''');
  }

  test_namedParameter_inferredType_var() async {
    await assertDiagnosticsFromMarkup(r'''
// @dart = 3.10
foo({[!var p = null!]}) {}
''');
  }

  test_optionalParameter_inferredType() async {
    await assertDiagnosticsFromMarkup(r'''
foo([[!p = null!]]) {}
''');
  }

  test_optionalParameter_inferredType_defaultValueIsInt() async {
    await assertNoDiagnostics(r'''
foo([p = 1]) {}
''');
  }

  test_optionalParameter_inferredType_noDefaultValue() async {
    await assertNoDiagnostics(r'''
foo([p]) {}
''');
  }

  test_optionalParameter_inferredType_var() async {
    await assertDiagnosticsFromMarkup(r'''
// @dart = 3.10
foo([[!var p = null!]]) {}
''');
  }

  test_staticConstField_inferredType_final() async {
    await assertNoDiagnostics(r'''
class C {
  static const i = null;
}
''');
  }

  test_topLevelVariable_dynamic() async {
    await assertDiagnosticsFromMarkup(r'''
dynamic [!i = null!];
''');
  }

  test_topLevelVariable_inferredType() async {
    await assertDiagnosticsFromMarkup(r'''
var [!i = null!];
''');
  }

  test_topLevelVariable_inferredType_const() async {
    await assertNoDiagnostics(r'''
const i = null;
''');
  }

  test_topLevelVariable_inferredType_final() async {
    await assertNoDiagnostics(r'''
final i = null;
''');
  }

  test_topLevelVariable_inferredType_initializeToInt() async {
    await assertNoDiagnostics(r'''
var i = 1;
''');
  }

  test_topLevelVariable_inferredType_noInitialization() async {
    await assertNoDiagnostics(r'''
var i;
''');
  }

  test_topLevelVariable_nullableType() async {
    await assertDiagnosticsFromMarkup(r'''
int? [!ii = null!];
''');
  }
}