// Copyright 2019 Dart Mockito authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

@TestOn('vm')
import 'package:build/build.dart';
import 'package:build/experiments.dart';
import 'package:build_test/build_test.dart';
import 'package:meta/meta.dart';
import 'package:mockito/src/builder.dart';
import 'package:package_config/package_config.dart';
import 'package:test/test.dart';

Builder buildMocks(BuilderOptions options) => MockBuilder();

const annotationsAsset = {
  'mockito|lib/annotations.dart': '''
class GenerateMocks {
  final List<Type> classes;
  final List<MockSpec> customMocks;

  const GenerateMocks(this.classes, {this.customMocks = []});
}

class MockSpec<T> {
  final Symbol mockName;

  final bool returnNullOnMissingStub;

  const MockSpec({Symbol as, this.returnNullOnMissingStub = false})
      : mockName = as;
}
'''
};

const mockitoAssets = {
  'mockito|lib/mockito.dart': '''
export 'src/mock.dart';
''',
  'mockito|lib/src/mock.dart': '''
class Mock {}
'''
};

const simpleTestAsset = {
  'foo|test/foo_test.dart': '''
import 'package:foo/foo.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([Foo])
void main() {}
'''
};

const _constructorWithThrowOnMissingStub = '''
MockFoo() {
    _i1.throwOnMissingStub(this);
  }''';

void main() {
  test(
      'generates a mock class but does not override methods w/ zero parameters',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        dynamic a() => 7;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('generates a mock class but does not override private methods',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int _b(int x) => 8;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('generates a mock class but does not override static methods', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        static int c(int y) => 9;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('generates a mock class but does not override any extension methods',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      extension X on Foo {
        dynamic x(int m, String n) => n + 1;
      }
      class Foo {}
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('overrides methods, matching required positional parameters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m(int a) {}
      }
      '''),
      _containsAllOf('void m(int? a) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('overrides methods, matching optional positional parameters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m(int a, [int b, int c = 0]) {}
      }
      '''),
      _containsAllOf('void m(int? a, [int? b, int? c = 0]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b, c]));'),
    );
  });

  test('overrides methods, matching named parameters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m(int a, {int b, int c = 0}) {}
      }
      '''),
      _containsAllOf('void m(int? a, {int? b, int? c = 0}) =>',
          'super.noSuchMethod(Invocation.method(#m, [a], {#b: b, #c: c}));'),
    );
  });

  test('matches parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([int a, int b = 0]) {}
      }
      '''),
      _containsAllOf('void m([int? a, int? b = 0]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches boolean literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([bool a = true, bool b = false]) {}
      }
      '''),
      _containsAllOf('void m([bool? a = true, bool? b = false]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches number literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([int a = 0, double b = 0.5]) {}
      }
      '''),
      _containsAllOf('void m([int? a = 0, double? b = 0.5]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches string literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([String a = 'Hello', String b = 'Hello ' r"World"]) {}
      }
      '''),
      _containsAllOf(
          "void m([String? a = r'Hello', String? b = r'Hello World']) =>",
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches empty collection literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([List<int> a = const [], Map<int, int> b = const {}]) {}
      }
      '''),
      _containsAllOf(
          'void m([List<int>? a = const [], Map<int, int>? b = const {}]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches non-empty list literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([List<int> a = const [1, 2, 3]]) {}
      }
      '''),
      _containsAllOf('void m([List<int>? a = const [1, 2, 3]]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches non-empty map literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Map<int, String> a = const {1: 'a', 2: 'b'}]) {}
      }
      '''),
      _containsAllOf(
          "void m([Map<int, String>? a = const {1: r'a', 2: r'b'}]) =>",
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches non-empty map literal parameter default values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Map<int, String> a = const {1: 'a', 2: 'b'}]) {}
      }
      '''),
      _containsAllOf(
          "void m([Map<int, String>? a = const {1: r'a', 2: r'b'}]) =>",
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed from a local class',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Bar a = const Bar()]) {}
      }
      class Bar {
        const Bar();
      }
      '''),
      _containsAllOf('void m([_i2.Bar? a = const _i2.Bar()]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed from a Dart SDK class',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Duration a = const Duration(days: 1)]) {}
      }
      '''),
      _containsAllOf('void m([Duration? a = const Duration(days: 1)]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed from a named constructor',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Bar a = const Bar.named()]) {}
      }
      class Bar {
        const Bar.named();
      }
      '''),
      _containsAllOf('void m([_i2.Bar? a = const _i2.Bar.named()]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed with positional arguments',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Bar a = const Bar(7)]) {}
      }
      class Bar {
        final int i;
        const Bar(this.i);
      }
      '''),
      _containsAllOf('void m([_i2.Bar? a = const _i2.Bar(7)]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed with named arguments',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([Bar a = const Bar(i: 7)]) {}
      }
      class Bar {
        final int i;
        const Bar({this.i});
      }
      '''),
      _containsAllOf('void m([_i2.Bar? a = const _i2.Bar(i: 7)]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed with top-level variable',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m([int a = x]) {}
      }
      const x = 1;
      '''),
      _containsAllOf('void m([int? a = 1]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches parameter default values constructed with static field',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        static const x = 1;
        void m([int a = x]) {}
      }
      '''),
      _containsAllOf('void m([int? a = 1]) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('throws when given a parameter default value using a private type', () {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
      class Foo {
        void m([Bar a = const _Bar()]) {}
      }
      class Bar {}
      class _Bar implements Bar {
        const _Bar();
      }
      '''),
      },
      message: contains(
          "Mockito cannot generate a valid stub for method 'Foo.m'; parameter "
          "'a' causes a problem: default value has a private type: "
          'asset:foo/lib/foo.dart#_Bar'),
    );
  });

  test(
      'throws when given a parameter default value using a private constructor',
      () {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          void m([Bar a = const Bar._named()]) {}
        }
        class Bar {
          const Bar._named();
        }
        '''),
      },
      message: contains(
          "Mockito cannot generate a valid stub for method 'Foo.m'; parameter "
          "'a' causes a problem: default value has a private type: "
          'asset:foo/lib/foo.dart#Bar::_named'),
    );
  });

  test('throws when given a parameter default value which is a type', () {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          void m([Type a = int]) {}
        }
        '''),
      },
      message: contains(
          "Mockito cannot generate a valid stub for method 'Foo.m'; parameter "
          "'a' causes a problem: default value is a Type: int"),
    );
  });

  test('overrides async methods legally', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Future<void> m() async => print(s);
      }
      '''),
      _containsAllOf('_i3.Future<void> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), Future.value(null));'),
    );
  });

  test('overrides async* methods legally', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Stream<int> m() async* { yield 7; }
      }
      '''),
      _containsAllOf('_i3.Stream<int> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), Stream<int>.empty());'),
    );
  });

  test('overrides sync* methods legally', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Iterable<int> m() sync* { yield 7; }
      }
      '''),
      _containsAllOf('Iterable<int> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), []);'),
    );
  });

  test('generates multiple mock classes', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        class Bar {}
        '''),
        'foo|test/foo_test.dart': '''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        @GenerateMocks([Foo, Bar])
        void main() {}
        '''
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': _containsAllOf(
          dedent('''
          class MockFoo extends _i1.Mock implements _i2.Foo {
            $_constructorWithThrowOnMissingStub
          }
          '''),
          dedent('''
          class MockBar extends _i1.Mock implements _i2.Bar {
            MockBar() {
              _i1.throwOnMissingStub(this);
            }
          }
          '''),
        ),
      },
    );
  });

  test('generates mock classes from multiple annotations', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        class Bar {}
        '''),
        'foo|test/foo_test.dart': '''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        @GenerateMocks([Foo])
        void fooTests() {}
        @GenerateMocks([Bar])
        void barTests() {}
        '''
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': _containsAllOf(
          dedent('''
          class MockFoo extends _i1.Mock implements _i2.Foo {
            $_constructorWithThrowOnMissingStub
          }
          '''),
          dedent('''
          class MockBar extends _i1.Mock implements _i2.Bar {
            MockBar() {
              _i1.throwOnMissingStub(this);
            }
          }
          '''),
        ),
      },
    );
  });

  test('generates mock classes from multiple annotations on a single element',
      () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        class Bar {}
        '''),
        'foo|test/foo_test.dart': '''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        @GenerateMocks([Foo])
        @GenerateMocks([Bar])
        void barTests() {}
        '''
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': _containsAllOf(
          dedent('''
          class MockFoo extends _i1.Mock implements _i2.Foo {
            $_constructorWithThrowOnMissingStub
          }
          '''),
          dedent('''
          class MockBar extends _i1.Mock implements _i2.Bar {
            MockBar() {
              _i1.throwOnMissingStub(this);
            }
          }
          '''),
        ),
      },
    );
  });

  test('generates generic mock classes', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo<T, U> {}
      '''),
      _containsAllOf(dedent('''
          class MockFoo<T, U> extends _i1.Mock implements _i2.Foo<T, U> {
            $_constructorWithThrowOnMissingStub
          }
          ''')),
    );
  });

  test('generates generic mock classes with type bounds', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        class Bar<T extends Foo> {}
        '''),
        'foo|test/foo_test.dart': '''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        @GenerateMocks([Foo, Bar])
        void main() {}
        '''
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': _containsAllOf(
          dedent('''
          class MockFoo extends _i1.Mock implements _i2.Foo {
            $_constructorWithThrowOnMissingStub
          }
          '''),
          dedent('''
          class MockBar<T extends _i2.Foo> extends _i1.Mock implements _i2.Bar<T> {
            MockBar() {
              _i1.throwOnMissingStub(this);
            }
          }
          '''),
        ),
      },
    );
  });

  test('writes dynamic, void w/o import prefix', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void m(dynamic a, int b) {}
      }
      '''),
      _containsAllOf(
        'void m(dynamic a, int? b) =>',
        'super.noSuchMethod(Invocation.method(#m, [a, b]));',
      ),
    );
  });

  test('writes type variables types w/o import prefixes', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        class Foo {
          void m<T>(T a) {}
        }
        '''),
      _containsAllOf(
        'void m<T>(T? a) => super.noSuchMethod(Invocation.method(#m, [a]));',
      ),
    );
  });

  test('imports libraries for external class types', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        import 'dart:async';
        class Foo {
          dynamic f(List<Foo> list) {}
        }
        '''),
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': dedent(r'''
        import 'package:mockito/mockito.dart' as _i1;
        import 'package:foo/foo.dart' as _i2;

        /// A class which mocks [Foo].
        ///
        /// See the documentation for Mockito's code generation for more information.
        class MockFoo extends _i1.Mock implements _i2.Foo {
          MockFoo() {
            _i1.throwOnMissingStub(this);
          }

          dynamic f(List<_i2.Foo>? list) =>
              super.noSuchMethod(Invocation.method(#f, [list]));
        }
        '''),
      },
    );
  });

  test('imports libraries for type aliases with external types', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        import 'dart:async';
        typedef Callback = void Function();
        typedef void Callback2();
        typedef Future<T> Callback3<T>();
        class Foo {
          dynamic f(Callback c) {}
          dynamic g(Callback2 c) {}
          dynamic h(Callback3<Foo> c) {}
        }
        '''),
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': dedent(r'''
        import 'package:mockito/mockito.dart' as _i1;
        import 'package:foo/foo.dart' as _i2;

        /// A class which mocks [Foo].
        ///
        /// See the documentation for Mockito's code generation for more information.
        class MockFoo extends _i1.Mock implements _i2.Foo {
          MockFoo() {
            _i1.throwOnMissingStub(this);
          }

          dynamic f(_i2.Callback? c) => super.noSuchMethod(Invocation.method(#f, [c]));
          dynamic g(_i2.Callback2? c) => super.noSuchMethod(Invocation.method(#g, [c]));
          dynamic h(_i2.Callback3<_i2.Foo>? c) =>
              super.noSuchMethod(Invocation.method(#h, [c]));
        }
        '''),
      },
    );
  });

  test('prefixes parameter type on generic function-typed parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      import 'dart:async';
      class Foo {
        dynamic m(void Function(Foo f) a) {}
      }
      '''),
      _containsAllOf('dynamic m(void Function(_i2.Foo)? a) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('prefixes return type on generic function-typed parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      import 'dart:async';
      class Foo {
        void m(Foo Function() a) {}
      }
      '''),
      _containsAllOf('void m(_i2.Foo Function()? a) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('prefixes parameter type on function-typed parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      import 'dart:async';
      class Foo {
        void m(void a(Foo f)) {}
      }
      '''),
      _containsAllOf('void m(void Function(_i2.Foo)? a) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('prefixes return type on function-typed parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      import 'dart:async';
      class Foo {
        void m(Foo a()) {}
      }
      '''),
      _containsAllOf('void m(_i2.Foo Function()? a) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('widens the type of parameters to be nullable', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(int? a, int b);
        }
        '''),
      _containsAllOf(
          'void m(int? a, int? b) => super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test(
      'widens the type of potentially non-nullable type variables to be '
      'nullable', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo<T> {
          void m(int? a, T b);
        }
        '''),
      _containsAllOf(
          'void m(int? a, T? b) => super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches nullability of type arguments of a parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(List<int?> a, List<int> b);
        }
        '''),
      _containsAllOf('void m(List<int?>? a, List<int>? b) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test(
      'matches nullability of return type of a generic function-typed '
      'parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(int? Function() a, int Function() b);
        }
        '''),
      _containsAllOf('void m(int? Function()? a, int Function()? b) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test(
      'matches nullability of parameter types within a generic function-typed '
      'parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(void Function(int?) a, void Function(int) b);
        }
        '''),
      _containsAllOf('void m(void Function(int?)? a, void Function(int)? b) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches nullability of return type of a function-typed parameter',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(int? a(), int b());
        }
        '''),
      _containsAllOf('void m(int? Function()? a, int Function()? b) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test(
      'matches nullability of parameter types within a function-typed '
      'parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(void a(int? x), void b(int x));
        }
        '''),
      _containsAllOf('void m(void Function(int?)? a, void Function(int)? b) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches nullability of a generic parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m<T>(T? a, T b);
        }
        '''),
      _containsAllOf(
          'void m<T>(T? a, T? b) => super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches nullability of a dynamic parameter', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          void m(dynamic a, int b);
        }
        '''),
      _containsAllOf('void m(dynamic a, int? b) =>',
          'super.noSuchMethod(Invocation.method(#m, [a, b]));'),
    );
  });

  test('matches nullability of non-nullable return type', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          int m(int a);
        }
        '''),
      _containsAllOf(
          'int m(int? a) => super.noSuchMethod(Invocation.method(#m, [a]), 0);'),
    );
  });

  test('matches nullability of nullable return type', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          int? m(int a);
        }
        '''),
      _containsAllOf(
          'int? m(int? a) => super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('matches nullability of return type type arguments', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          List<int?> m(int a);
        }
        '''),
      _containsAllOf('List<int?> m(int? a) =>',
          'super.noSuchMethod(Invocation.method(#m, [a]), <int?>[]);'),
    );
  });

  test('matches nullability of nullable type variable return type', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          T? m<T>(int a);
        }
        '''),
      _containsAllOf(
          'T? m<T>(int? a) => super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('overrides implicit return type with dynamic', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          m(int a);
        }
        '''),
      _containsAllOf(
          'dynamic m(int? a) => super.noSuchMethod(Invocation.method(#m, [a]));'),
    );
  });

  test('overrides abstract methods', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      abstract class Foo {
        dynamic f(int a);
      }
      '''),
      _containsAllOf(
          'dynamic f(int? a) => super.noSuchMethod(Invocation.method(#f, [a]));'),
    );
  });

  test('does not override methods with all nullable parameters', () async {
    await _expectSingleNonNullableOutput(
      dedent('''
      class Foo {
        void a(int? p) {}
        void b(dynamic p) {}
        void c(var p) {}
        void d(final p) {}
        void e(int Function()? p) {}
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('does not override methods with a void return type', () async {
    await _expectSingleNonNullableOutput(
      dedent('''
      abstract class Foo {
        void m();
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('does not override methods with an implicit dynamic return type',
      () async {
    await _expectSingleNonNullableOutput(
      dedent('''
      abstract class Foo {
        m();
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('does not override methods with an explicit dynamic return type',
      () async {
    await _expectSingleNonNullableOutput(
      dedent('''
      abstract class Foo {
        dynamic m();
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('does not override methods with a nullable return type', () async {
    await _expectSingleNonNullableOutput(
      dedent('''
      abstract class Foo {
        int? m();
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('overrides methods with a non-nullable return type', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
        abstract class Foo {
          int m();
        }
        '''),
      _containsAllOf(
          'int m() => super.noSuchMethod(Invocation.method(#m, []), 0);'),
    );
  });

  test('overrides methods with a potentially non-nullable parameter', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo<T> {
          void a(T m) {}
        }
        '''),
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': _containsAllOf(
            'void a(T? m) => super.noSuchMethod(Invocation.method(#a, [m]));'),
      },
    );
  });

  test('overrides generic methods', () async {
    await _testWithNonNullable(
      {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          dynamic f<T>(int a) {}
          dynamic g<T extends Foo>(int a) {}
        }
        '''),
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': dedent(r'''
        import 'package:mockito/mockito.dart' as _i1;
        import 'package:foo/foo.dart' as _i2;

        /// A class which mocks [Foo].
        ///
        /// See the documentation for Mockito's code generation for more information.
        class MockFoo extends _i1.Mock implements _i2.Foo {
          MockFoo() {
            _i1.throwOnMissingStub(this);
          }

          dynamic f<T>(int? a) => super.noSuchMethod(Invocation.method(#f, [a]));
          dynamic g<T extends _i2.Foo>(int? a) =>
              super.noSuchMethod(Invocation.method(#g, [a]));
        }
        '''),
      },
    );
  });

  test('overrides non-nullable instance getters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int get m => 7;
      }
      '''),
      _containsAllOf(
          'int get m => super.noSuchMethod(Invocation.getter(#m), 0);'),
    );
  });

  test('does not override nullable instance getters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int? get m => 7;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('overrides non-nullable instance setters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void set m(int a) {}
      }
      '''),
      _containsAllOf(
          'set m(int? a) => super.noSuchMethod(Invocation.setter(#m, [a]));'),
    );
  });

  test('does not override nullable instance setters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void set m(int? a) {}
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('overrides non-nullable fields', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int m;
      }
      '''),
      _containsAllOf(
          'int get m => super.noSuchMethod(Invocation.getter(#m), 0);',
          'set m(int? _m) => super.noSuchMethod(Invocation.setter(#m, [_m]));'),
    );
  });

  test('overrides final non-nullable fields', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        final int m;
        Foo(this.m);
      }
      '''),
      _containsAllOf(
          'int get m => super.noSuchMethod(Invocation.getter(#m), 0);'),
    );
  });

  test('does not override nullable fields', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int? m;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('does not override private fields', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int _a;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('does not override static fields', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        static int b;
      }
      '''),
      _containsAllOf(dedent('''
      class MockFoo extends _i1.Mock implements _i2.Foo {
        $_constructorWithThrowOnMissingStub
      }
      ''')),
    );
  });

  test('overrides binary operators', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int operator +(Foo other) => 7;
      }
      '''),
      _containsAllOf('int operator +(_i2.Foo? other) =>',
          'super.noSuchMethod(Invocation.method(#+, [other]), 0);'),
    );
  });

  test('overrides index operators', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int operator [](int x) => 7;
      }
      '''),
      _containsAllOf(
          'int operator [](int? x) => super.noSuchMethod(Invocation.method(#[], [x]), 0);'),
    );
  });

  test('overrides unary operators', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int operator ~() => 7;
      }
      '''),
      _containsAllOf(
          'int operator ~() => super.noSuchMethod(Invocation.method(#~, []), 0);'),
    );
  });

  test('creates dummy non-null bool return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        bool m() => false;
      }
      '''),
      _containsAllOf(
          'bool m() => super.noSuchMethod(Invocation.method(#m, []), false);'),
    );
  });

  test('creates dummy non-null double return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        double m() => 3.14;
      }
      '''),
      _containsAllOf(
          'double m() => super.noSuchMethod(Invocation.method(#m, []), 0.0);'),
    );
  });

  test('creates dummy non-null int return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        int m() => 7;
      }
      '''),
      _containsAllOf(
          'int m() => super.noSuchMethod(Invocation.method(#m, []), 0);'),
    );
  });

  test('creates dummy non-null String return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        String m() => "Hello";
      }
      '''),
      _containsAllOf(
          "String m() => super.noSuchMethod(Invocation.method(#m, []), '');"),
    );
  });

  test('creates dummy non-null List return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        List<Foo> m() => [Foo()];
      }
      '''),
      _containsAllOf('List<_i2.Foo> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), <_i2.Foo>[]);'),
    );
  });

  test('creates dummy non-null Set return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Set<Foo> m() => {Foo()};
      }
      '''),
      _containsAllOf('Set<_i2.Foo> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), <_i2.Foo>{});'),
    );
  });

  test('creates dummy non-null Map return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Map<int, Foo> m() => {7: Foo()};
      }
      '''),
      _containsAllOf('Map<int, _i2.Foo> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), <int, _i2.Foo>{});'),
    );
  });

  test('creates dummy non-null raw-typed return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      abstract class Foo {
        Map m();
      }
      '''),
      _containsAllOf('Map<dynamic, dynamic> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), <dynamic, dynamic>{});'),
    );
  });

  test('creates dummy non-null return values for Futures of known core classes',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Future<bool> m() async => false;
      }
      '''),
      _containsAllOf('_i3.Future<bool> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), Future.value(false));'),
    );
  });

  test('creates dummy non-null Stream return value', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      abstract class Foo {
        Stream<int> m();
      }
      '''),
      _containsAllOf('Stream<int> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), Stream<int>.empty());'),
    );
  });

  test('creates dummy non-null return values for unknown classes', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Bar m() => Bar('name');
      }
      class Bar {
        final String name;
        Bar(this.name);
      }
      '''),
      _containsAllOf(
          '_i2.Bar m() => super.noSuchMethod(Invocation.method(#m, []), _FakeBar());'),
    );
  });

  test('creates dummy non-null return values for generic type', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      abstract class Foo {
        Bar<int> m();
      }
      class Bar<T> {}
      '''),
      _containsAllOf('Bar<int> m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), _FakeBar<int>());'),
    );
  });

  test('creates dummy non-null return values for enums', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Bar m1() => Bar('name');
      }
      enum Bar {
        one,
        two,
      }
      '''),
      _containsAllOf(
          '_i2.Bar m1() => super.noSuchMethod(Invocation.method(#m1, []), _i2.Bar.one);'),
    );
  });

  test(
      'creates a dummy non-null function-typed return value, with optional '
      'parameters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void Function(int, [String]) m() => (int i, [String s]) {};
      }
      '''),
      _containsAllOf('void Function(int, [String]) m() => super',
          '.noSuchMethod(Invocation.method(#m, []), (int __p0, [String __p1]) {});'),
    );
  });

  test(
      'creates a dummy non-null function-typed return value, with named '
      'parameters', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        void Function(Foo, {bool b}) m() => (Foo f, {bool b}) {};
      }
      '''),
      _containsAllOf('void Function(_i2.Foo, {bool b}) m() => super',
          '.noSuchMethod(Invocation.method(#m, []), (_i2.Foo __p0, {bool b}) {});'),
    );
  });

  test(
      'creates a dummy non-null function-typed return value, with non-core '
      'return type', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Foo Function() m() => () => Foo();
      }
      '''),
      _containsAllOf('_i2.Foo Function() m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), () => _FakeFoo());'),
    );
  });

  test('creates a dummy non-null generic function-typed return value',
      () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        T? Function<T>(T) m() => (int i, [String s]) {};
      }
      '''),
      // TODO(srawlins): This output is invalid: `T __p0` is out of the scope
      // where T is defined.
      _containsAllOf('T? Function<T>(T) m() =>',
          'super.noSuchMethod(Invocation.method(#m, []), (T __p0) => null);'),
    );
  });

  test('generates a fake class used in return values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Bar m1() => Bar('name1');
      }
      class Bar {}
      '''),
      _containsAllOf('class _FakeBar extends _i1.Fake implements _i2.Bar {}'),
    );
  });

  test('generates a fake generic class used in return values', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Bar m1() => Bar('name1');
      }
      class Bar<T, U> {}
      '''),
      _containsAllOf(
          'class _FakeBar<T, U> extends _i1.Fake implements _i2.Bar<T, U> {}'),
    );
  });

  test('deduplicates fake classes', () async {
    await _expectSingleNonNullableOutput(
      dedent(r'''
      class Foo {
        Bar m1() => Bar('name1');
        Bar m2() => Bar('name2');
      }
      class Bar {
        final String name;
        Bar(this.name);
      }
      '''),
      dedent(r'''
      import 'package:mockito/mockito.dart' as _i1;
      import 'package:foo/foo.dart' as _i2;

      class _FakeBar extends _i1.Fake implements _i2.Bar {}

      /// A class which mocks [Foo].
      ///
      /// See the documentation for Mockito's code generation for more information.
      class MockFoo extends _i1.Mock implements _i2.Foo {
        MockFoo() {
          _i1.throwOnMissingStub(this);
        }

        _i2.Bar m1() => super.noSuchMethod(Invocation.method(#m1, []), _FakeBar());
        _i2.Bar m2() => super.noSuchMethod(Invocation.method(#m2, []), _FakeBar());
      }
      '''),
    );
  });

  test('throws when GenerateMocks is given a class multiple times', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        '''),
        'foo|test/foo_test.dart': '''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        @GenerateMocks([Foo, Foo])
        void main() {}
        '''
      },
      message: contains(
          'Mockito cannot generate two mocks with the same name: MockFoo (for '
          'Foo declared in /foo/lib/foo.dart, and for Foo declared in '
          '/foo/lib/foo.dart)'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'private return type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo {
          _Bar m(int a);
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private return type, and cannot be "
          'stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a return '
      'type with private type arguments', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo {
          List<_Bar> m(int a);
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private type argument, and cannot be "
          'stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a return '
      'function type, with a private return type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo {
          _Bar Function() m();
        }
        class _Bar {}
        '''),
      },
      message: contains("The method 'Foo.m' features a private return type, "
          'and cannot be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'private parameter type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          void m(_Bar a) {}
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private parameter type, '_Bar', and "
          'cannot be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'parameter with private type arguments', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          void m(List<_Bar> a) {}
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private type argument, and cannot be "
          'stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'function parameter type, with a private return type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          void m(_Bar Function() a) {}
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private return type, and cannot be "
          'stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a return '
      'function type, with a private parameter type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo {
          Function(_Bar) m();
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private parameter type, '_Bar', and "
          'cannot be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a type parameter with a '
      'private bound', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo<T extends _Bar> {
          void m(int a) {}
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The class 'Foo' features a private type parameter bound, and cannot "
          'be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'type parameter with a private bound', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {
          void m<T extends _Bar>(int a) {}
        }
        class _Bar {}
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a private type parameter bound, and "
          'cannot be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'non-nullable class-declared type variable return type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo<T> {
          T m(int a);
        }
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a non-nullable unknown return type, and "
          'cannot be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'non-nullable method-declared type variable return type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo {
          T m<T>(int a);
        }
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a non-nullable unknown return type, and "
          'cannot be stubbed.'),
    );
  });

  test(
      'throws when GenerateMocks is given a class with a method with a '
      'non-nullable method-declared bounded type variable return type',
      () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent('''
        abstract class Foo {
          T m<T extends num>(int a);
        }
        '''),
      },
      message: contains(
          "The method 'Foo.m' features a non-nullable unknown return type, and "
          'cannot be stubbed.'),
    );
  });

  test('throws when GenerateMocks is missing an argument', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|test/foo_test.dart': dedent('''
        import 'package:mockito/annotations.dart';
        // Missing required argument to GenerateMocks.
        @GenerateMocks()
        void main() {}
        '''),
      },
      message: contains('The GenerateMocks "classes" argument is missing'),
    );
  });

  test('throws when GenerateMocks is given a private class', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|test/foo_test.dart': dedent('''
        import 'package:mockito/annotations.dart';
        @GenerateMocks([_Foo])
        void main() {}
        class _Foo {}
        '''),
      },
      message: contains('Mockito cannot mock a private type: _Foo.'),
    );
  });

  test('throws when GenerateMocks references an unresolved type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        '''),
        'foo|test/foo_test.dart': dedent('''
        // missing foo.dart import.
        import 'package:mockito/annotations.dart';
        @GenerateMocks([List, Foo])
        void main() {}
        '''),
      },
      message: contains('includes an unknown type'),
    );
  });

  test('throws when two distinct classes with the same name are mocked',
      () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|lib/a.dart': dedent(r'''
        class Foo {}
        '''),
        'foo|lib/b.dart': dedent(r'''
        class Foo {}
        '''),
        'foo|test/foo_test.dart': dedent('''
        import 'package:foo/a.dart' as a;
        import 'package:foo/b.dart' as b;
        import 'package:mockito/annotations.dart';
        @GenerateMocks([a.Foo, b.Foo])
        void main() {}
        '''),
      },
      message: contains(
          'Mockito cannot generate two mocks with the same name: MockFoo (for '
          'Foo declared in /foo/lib/a.dart, and for Foo declared in '
          '/foo/lib/b.dart)'),
    );
  });

  test('throws when a mock class of the same name already exists', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        '''),
        'foo|test/foo_test.dart': dedent('''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        @GenerateMocks([Foo])
        void main() {}
        class MockFoo {}
        '''),
      },
      message: contains(
          'Mockito cannot generate a mock with a name which conflicts with '
          'another class declared in this library: MockFoo'),
    );
  });

  test('throws when a mock class of class-to-mock already exists', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...mockitoAssets,
        'foo|lib/foo.dart': dedent(r'''
        class Foo {}
        '''),
        'foo|test/foo_test.dart': dedent('''
        import 'package:foo/foo.dart';
        import 'package:mockito/annotations.dart';
        import 'package:mockito/mockito.dart';
        @GenerateMocks([Foo])
        void main() {}
        class FakeFoo extends Mock implements Foo {}
        '''),
      },
      message: contains(
          'contains a class which appears to already be mocked inline: FakeFoo'),
    );
  });

  test('throws when GenerateMocks references a non-type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|test/foo_test.dart': dedent('''
        import 'package:mockito/annotations.dart';
        @GenerateMocks([7])
        void main() {}
        '''),
      },
      message: 'The "classes" argument includes a non-type: int (7)',
    );
  });

  test('throws when GenerateMocks references a typedef', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        typedef Foo = void Function();
        '''),
      },
      message: 'Mockito cannot mock a typedef: Foo',
    );
  });

  test('throws when GenerateMocks references an enum', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        enum Foo {}
        '''),
      },
      message: 'Mockito cannot mock an enum: Foo',
    );
  });

  test('throws when GenerateMocks references an extension', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        extension Foo on String {}
        '''),
      },
      message: contains('includes an extension'),
    );
  });

  test('throws when GenerateMocks references a non-subtypeable type', () async {
    _expectBuilderThrows(
      assets: {
        ...annotationsAsset,
        'foo|test/foo_test.dart': dedent('''
        import 'package:mockito/annotations.dart';
        @GenerateMocks([int])
        void main() {}
        '''),
      },
      message: contains('Mockito cannot mock a non-subtypable type: int'),
    );
  });

  test('given a pre-non-nullable library, does not override any members',
      () async {
    await _testPreNonNullable(
      {
        ...annotationsAsset,
        ...simpleTestAsset,
        'foo|lib/foo.dart': dedent(r'''
        abstract class Foo {
          int f(int a);
        }
        '''),
      },
      outputs: {
        'foo|test/foo_test.mocks.dart': _containsAllOf(dedent('''
        class MockFoo extends _i1.Mock implements _i2.Foo {
          MockFoo() {
            _i1.throwOnMissingStub(this);
          }
        }
        '''))
      },
    );
  });
}

/// Test [MockBuilder] in a package which has not opted into the non-nullable
/// type system.
///
/// Whether the non-nullable experiment is enabled depends on the SDK executing
/// this test, but that does not affect the opt-in state of the package under
/// test.
Future<void> _testPreNonNullable(Map<String, String> sourceAssets,
    {Map<String, /*String|Matcher<String>*/ dynamic> outputs}) async {
  var packageConfig = PackageConfig([
    Package('foo', Uri.file('/foo/'),
        packageUriRoot: Uri.file('/foo/lib/'),
        languageVersion: LanguageVersion(2, 7))
  ]);
  await testBuilder(buildMocks(BuilderOptions({})), sourceAssets,
      outputs: outputs, packageConfig: packageConfig);
}

/// Test [MockBuilder] in a package which has opted into the non-nullable type
/// system, and with the non-nullable experiment enabled.
Future<void> _testWithNonNullable(Map<String, String> sourceAssets,
    {Map<String, /*String|Matcher<List<int>>*/ dynamic> outputs}) async {
  var packageConfig = PackageConfig([
    Package('foo', Uri.file('/foo/'),
        packageUriRoot: Uri.file('/foo/lib/'),
        languageVersion: LanguageVersion(2, 9))
  ]);
  await withEnabledExperiments(
    () async => await testBuilder(buildMocks(BuilderOptions({})), sourceAssets,
        outputs: outputs, packageConfig: packageConfig),
    ['non-nullable'],
  );
}

/// Test [MockBuilder] on a single source file, in a package which has opted
/// into the non-nullable type system, and with the non-nullable experiment
/// enabled.
Future<void> _expectSingleNonNullableOutput(
    String sourceAssetText,
    /*String|Matcher<List<int>>*/ dynamic output) async {
  var packageConfig = PackageConfig([
    Package('foo', Uri.file('/foo/'),
        packageUriRoot: Uri.file('/foo/lib/'),
        languageVersion: LanguageVersion(2, 9))
  ]);

  await withEnabledExperiments(
    () async => await testBuilder(
        buildMocks(BuilderOptions({})),
        {
          ...annotationsAsset,
          ...simpleTestAsset,
          'foo|lib/foo.dart': sourceAssetText,
        },
        outputs: {'foo|test/foo_test.mocks.dart': output},
        packageConfig: packageConfig),
    ['non-nullable'],
  );
}

TypeMatcher<List<int>> _containsAllOf(a, [b]) => decodedMatches(
    b == null ? allOf(contains(a)) : allOf(contains(a), contains(b)));

/// Expect that [testBuilder], given [assets], throws an
/// [InvalidMockitoAnnotationException] with a message containing [message].
void _expectBuilderThrows(
    {@required Map<String, String> assets,
    @required dynamic /*String|Matcher<List<int>>*/ message}) {
  var packageConfig = PackageConfig([
    Package('foo', Uri.file('/foo/'),
        packageUriRoot: Uri.file('/foo/lib/'),
        languageVersion: LanguageVersion(2, 9))
  ]);

  expect(
      () async => await withEnabledExperiments(
            () async => await testBuilder(
                buildMocks(BuilderOptions({})), assets,
                packageConfig: packageConfig),
            ['non-nullable'],
          ),
      throwsA(TypeMatcher<InvalidMockitoAnnotationException>()
          .having((e) => e.message, 'message', message)));
}

/// Dedent [input], so that each line is shifted to the left, so that the first
/// line is at the 0 column.
String dedent(String input) {
  final indentMatch = RegExp(r'^(\s*)').firstMatch(input);
  final indent = ''.padRight(indentMatch.group(1).length);
  return input.splitMapJoin('\n',
      onNonMatch: (s) => s.replaceFirst(RegExp('^$indent'), ''));
}