diff --git a/example/example.dart b/example/example.dart
index 9742c3a..3a708b5 100644
--- a/example/example.dart
+++ b/example/example.dart
@@ -5,9 +5,9 @@
 
 // Real class
 class Cat {
-  String sound() => "Meow";
+  String sound() => 'Meow';
   bool eatFood(String food, {bool hungry}) => true;
-  Future<void> chew() async => print("Chewing...");
+  Future<void> chew() async => print('Chewing...');
   int walk(List<String> places) => 7;
   void sleep() {}
   void hunt(String place, String prey) {}
@@ -42,20 +42,20 @@
     verify(cat.sound());
   });
 
-  test("How about some stubbing?", () {
+  test('How about some stubbing?', () {
     // Unstubbed methods return null.
     expect(cat.sound(), null);
 
     // Stub a method before interacting with it.
-    when(cat.sound()).thenReturn("Purr");
-    expect(cat.sound(), "Purr");
+    when(cat.sound()).thenReturn('Purr');
+    expect(cat.sound(), 'Purr');
 
     // You can call it again.
-    expect(cat.sound(), "Purr");
+    expect(cat.sound(), 'Purr');
 
     // Let's change the stub.
-    when(cat.sound()).thenReturn("Meow");
-    expect(cat.sound(), "Meow");
+    when(cat.sound()).thenReturn('Meow');
+    expect(cat.sound(), 'Meow');
 
     // You can stub getters.
     when(cat.lives).thenReturn(9);
@@ -66,48 +66,48 @@
     expect(() => cat.lives, throwsRangeError);
 
     // We can calculate a response at call time.
-    var responses = ["Purr", "Meow"];
+    var responses = ['Purr', 'Meow'];
     when(cat.sound()).thenAnswer((_) => responses.removeAt(0));
-    expect(cat.sound(), "Purr");
-    expect(cat.sound(), "Meow");
+    expect(cat.sound(), 'Purr');
+    expect(cat.sound(), 'Meow');
   });
 
-  test("Argument matchers", () {
+  test('Argument matchers', () {
     // You can use plain arguments themselves
-    when(cat.eatFood("fish")).thenReturn(true);
+    when(cat.eatFood('fish')).thenReturn(true);
 
     // ... including collections
-    when(cat.walk(["roof", "tree"])).thenReturn(2);
+    when(cat.walk(['roof', 'tree'])).thenReturn(2);
 
     // ... or matchers
-    when(cat.eatFood(argThat(startsWith("dry")))).thenReturn(false);
+    when(cat.eatFood(argThat(startsWith('dry')))).thenReturn(false);
 
     // ... or mix aguments with matchers
-    when(cat.eatFood(argThat(startsWith("dry")), hungry: true))
+    when(cat.eatFood(argThat(startsWith('dry')), hungry: true))
         .thenReturn(true);
-    expect(cat.eatFood("fish"), isTrue);
-    expect(cat.walk(["roof", "tree"]), equals(2));
-    expect(cat.eatFood("dry food"), isFalse);
-    expect(cat.eatFood("dry food", hungry: true), isTrue);
+    expect(cat.eatFood('fish'), isTrue);
+    expect(cat.walk(['roof', 'tree']), equals(2));
+    expect(cat.eatFood('dry food'), isFalse);
+    expect(cat.eatFood('dry food', hungry: true), isTrue);
 
     // You can also verify using an argument matcher.
-    verify(cat.eatFood("fish"));
-    verify(cat.walk(["roof", "tree"]));
-    verify(cat.eatFood(argThat(contains("food"))));
+    verify(cat.eatFood('fish'));
+    verify(cat.walk(['roof', 'tree']));
+    verify(cat.eatFood(argThat(contains('food'))));
 
     // You can verify setters.
     cat.lives = 9;
     verify(cat.lives = 9);
 
-    cat.hunt("backyard", null);
-    verify(cat.hunt("backyard", null)); // OK: no arg matchers.
+    cat.hunt('backyard', null);
+    verify(cat.hunt('backyard', null)); // OK: no arg matchers.
 
-    cat.hunt("backyard", null);
-    verify(cat.hunt(argThat(contains("yard")),
+    cat.hunt('backyard', null);
+    verify(cat.hunt(argThat(contains('yard')),
         argThat(isNull))); // OK: null is wrapped in an arg matcher.
   });
 
-  test("Named arguments", () {
+  test('Named arguments', () {
     // GOOD: argument matchers include their names.
     when(cat.eatFood(any, hungry: anyNamed('hungry'))).thenReturn(true);
     when(cat.eatFood(any, hungry: argThat(isNotNull, named: 'hungry')))
@@ -117,7 +117,7 @@
         .thenReturn(true);
   });
 
-  test("Verifying exact number of invocations / at least x / never", () {
+  test('Verifying exact number of invocations / at least x / never', () {
     cat.sound();
     cat.sound();
     // Exact number of invocations
@@ -133,41 +133,41 @@
     verifyNever(cat.eatFood(any));
   });
 
-  test("Verification in order", () {
-    cat.eatFood("Milk");
+  test('Verification in order', () {
+    cat.eatFood('Milk');
     cat.sound();
-    cat.eatFood("Fish");
-    verifyInOrder([cat.eatFood("Milk"), cat.sound(), cat.eatFood("Fish")]);
+    cat.eatFood('Fish');
+    verifyInOrder([cat.eatFood('Milk'), cat.sound(), cat.eatFood('Fish')]);
   });
 
-  test("Making sure interaction(s) never happened on mock", () {
+  test('Making sure interaction(s) never happened on mock', () {
     verifyZeroInteractions(cat);
   });
 
-  test("Finding redundant invocations", () {
+  test('Finding redundant invocations', () {
     cat.sound();
     verify(cat.sound());
     verifyNoMoreInteractions(cat);
   });
 
-  test("Capturing arguments for further assertions", () {
+  test('Capturing arguments for further assertions', () {
     // Simple capture:
-    cat.eatFood("Fish");
-    expect(verify(cat.eatFood(captureAny)).captured.single, "Fish");
+    cat.eatFood('Fish');
+    expect(verify(cat.eatFood(captureAny)).captured.single, 'Fish');
 
     // Capture multiple calls:
-    cat.eatFood("Milk");
-    cat.eatFood("Fish");
-    expect(verify(cat.eatFood(captureAny)).captured, ["Milk", "Fish"]);
+    cat.eatFood('Milk');
+    cat.eatFood('Fish');
+    expect(verify(cat.eatFood(captureAny)).captured, ['Milk', 'Fish']);
 
     // Conditional capture:
-    cat.eatFood("Milk");
-    cat.eatFood("Fish");
+    cat.eatFood('Milk');
+    cat.eatFood('Fish');
     expect(
-        verify(cat.eatFood(captureThat(startsWith("F")))).captured, ["Fish"]);
+        verify(cat.eatFood(captureThat(startsWith('F')))).captured, ['Fish']);
   });
 
-  test("Waiting for an interaction", () async {
+  test('Waiting for an interaction', () async {
     Future<void> chewHelper(Cat cat) {
       return cat.chew();
     }
@@ -177,15 +177,15 @@
     await untilCalled(cat.chew()); // This completes when cat.chew() is called.
 
     // Waiting for a call that has already happened.
-    cat.eatFood("Fish");
+    cat.eatFood('Fish');
     await untilCalled(cat.eatFood(any)); // This completes immediately.
   });
 
-  test("Fake class", () {
+  test('Fake class', () {
     // Create a new fake Cat at runtime.
     var cat = FakeCat();
 
-    cat.eatFood("Milk"); // Prints 'Fake eat Milk'.
+    cat.eatFood('Milk'); // Prints 'Fake eat Milk'.
     expect(() => cat.sleep(), throwsUnimplementedError);
   });
 }
diff --git a/example/iss/iss.dart b/example/iss/iss.dart
index e932fd9..eef8df4 100644
--- a/example/iss/iss.dart
+++ b/example/iss/iss.dart
@@ -31,9 +31,7 @@
 
   /// Returns the current GPS position in [latitude, longitude] format.
   Future update() async {
-    if (_ongoingRequest == null) {
-      _ongoingRequest = _doUpdate();
-    }
+    _ongoingRequest ??= _doUpdate();
     await _ongoingRequest;
     _ongoingRequest = null;
   }
@@ -41,7 +39,7 @@
   Future _doUpdate() async {
     // Returns the point on the earth directly under the space station
     // at this moment.
-    Response rs = await client.get('http://api.open-notify.org/iss-now.json');
+    var rs = await client.get('http://api.open-notify.org/iss-now.json');
     var data = jsonDecode(rs.body);
     var latitude = double.parse(data['iss_position']['latitude'] as String);
     var longitude = double.parse(data['iss_position']['longitude'] as String);
@@ -60,7 +58,7 @@
   // The ISS is defined to be visible if the distance from the observer to
   // the point on the earth directly under the space station is less than 80km.
   bool get isVisible {
-    double distance = sphericalDistanceKm(locator.currentPosition, observer);
+    var distance = sphericalDistanceKm(locator.currentPosition, observer);
     return distance < 80.0;
   }
 }
diff --git a/example/iss/iss_test.dart b/example/iss/iss_test.dart
index 3aa2a62..dc4f3cd 100644
--- a/example/iss/iss_test.dart
+++ b/example/iss/iss_test.dart
@@ -27,18 +27,18 @@
   // verify the calculated distance between them.
   group('Spherical distance', () {
     test('London - Paris', () {
-      Point<double> london = Point(51.5073, -0.1277);
-      Point<double> paris = Point(48.8566, 2.3522);
-      double d = sphericalDistanceKm(london, paris);
+      var london = Point(51.5073, -0.1277);
+      var paris = Point(48.8566, 2.3522);
+      var d = sphericalDistanceKm(london, paris);
       // London should be approximately 343.5km
       // (+/- 0.1km) from Paris.
       expect(d, closeTo(343.5, 0.1));
     });
 
     test('San Francisco - Mountain View', () {
-      Point<double> sf = Point(37.783333, -122.416667);
-      Point<double> mtv = Point(37.389444, -122.081944);
-      double d = sphericalDistanceKm(sf, mtv);
+      var sf = Point(37.783333, -122.416667);
+      var mtv = Point(37.389444, -122.081944);
+      var d = sphericalDistanceKm(sf, mtv);
       // San Francisco should be approximately 52.8km
       // (+/- 0.1km) from Mountain View.
       expect(d, closeTo(52.8, 0.1));
@@ -52,8 +52,8 @@
   // second predefined location. This test runs asynchronously.
   group('ISS spotter', () {
     test('ISS visible', () async {
-      Point<double> sf = Point(37.783333, -122.416667);
-      Point<double> mtv = Point(37.389444, -122.081944);
+      var sf = Point(37.783333, -122.416667);
+      var mtv = Point(37.389444, -122.081944);
       IssLocator locator = MockIssLocator();
       // Mountain View should be visible from San Francisco.
       when(locator.currentPosition).thenReturn(sf);
@@ -63,8 +63,8 @@
     });
 
     test('ISS not visible', () async {
-      Point<double> london = Point(51.5073, -0.1277);
-      Point<double> mtv = Point(37.389444, -122.081944);
+      var london = Point(51.5073, -0.1277);
+      var mtv = Point(37.389444, -122.081944);
       IssLocator locator = MockIssLocator();
       // London should not be visible from Mountain View.
       when(locator.currentPosition).thenReturn(london);
diff --git a/lib/src/mock.dart b/lib/src/mock.dart
index 320586e..d83c070 100644
--- a/lib/src/mock.dart
+++ b/lib/src/mock.dart
@@ -17,6 +17,7 @@
 import 'package:meta/meta.dart';
 import 'package:mockito/src/call_pair.dart';
 import 'package:mockito/src/invocation_matcher.dart';
+// ignore: deprecated_member_use
 import 'package:test_api/test_api.dart';
 // TODO(srawlins): Remove this when we no longer need to check for an
 // incompatiblity between test_api and test.
@@ -37,7 +38,8 @@
 @Deprecated(
     'This function is not a supported function, and may be deleted as early as '
     'Mockito 5.0.0')
-void setDefaultResponse(Mock mock, CallPair<dynamic> defaultResponse()) {
+void setDefaultResponse(
+    Mock mock, CallPair<dynamic> Function() defaultResponse) {
   mock._defaultResponse = defaultResponse;
 }
 
@@ -136,7 +138,7 @@
       const Object().noSuchMethod(invocation);
 
   @override
-  int get hashCode => _givenHashCode == null ? 0 : _givenHashCode;
+  int get hashCode => _givenHashCode ?? 0;
 
   @override
   bool operator ==(other) => (_givenHashCode != null && other is Mock)
@@ -144,7 +146,7 @@
       : identical(this, other);
 
   @override
-  String toString() => _givenName != null ? _givenName : runtimeType.toString();
+  String toString() => _givenName ?? runtimeType.toString();
 
   String _realCallsToString() {
     var stringRepresentations = _realCalls.map((call) => call.toString());
@@ -238,7 +240,7 @@
   factory _InvocationForMatchedArguments(Invocation invocation) {
     if (_storedArgs.isEmpty && _storedNamedArgs.isEmpty) {
       throw StateError(
-          "_InvocationForMatchedArguments called when no ArgMatchers have been saved.");
+          '_InvocationForMatchedArguments called when no ArgMatchers have been saved.');
     }
 
     // Handle named arguments first, so that we can provide useful errors for
@@ -289,7 +291,7 @@
     // Iterate through the stored named args, validate them, and add them to
     // the return map.
     _storedNamedArgs.forEach((name, arg) {
-      Symbol nameSymbol = Symbol(name);
+      var nameSymbol = Symbol(name);
       if (!invocation.namedArguments.containsKey(nameSymbol)) {
         // Clear things out for the next call.
         _storedArgs.clear();
@@ -344,8 +346,8 @@
           'needs to specify the name of the argument it is being used in. For '
           'example: `when(obj.fn(x: anyNamed("x")))`).');
     }
-    int storedIndex = 0;
-    int positionalIndex = 0;
+    var storedIndex = 0;
+    var positionalIndex = 0;
     while (storedIndex < _storedArgs.length &&
         positionalIndex < invocation.positionalArguments.length) {
       var arg = _storedArgs[storedIndex];
@@ -456,7 +458,7 @@
   }
 
   void _captureArguments(Invocation invocation) {
-    int index = 0;
+    var index = 0;
     for (var roleArg in roleInvocation.positionalArguments) {
       var actArg = invocation.positionalArguments[index];
       if (roleArg is ArgMatcher && roleArg._capture) {
@@ -484,7 +486,7 @@
         roleInvocation.namedArguments.length) {
       return false;
     }
-    int index = 0;
+    var index = 0;
     for (var roleArg in roleInvocation.positionalArguments) {
       var actArg = invocation.positionalArguments[index];
       if (!isMatchingArg(roleArg, actArg)) {
@@ -541,8 +543,7 @@
   @override
   String toString() {
     var argString = '';
-    var args = invocation.positionalArguments
-        .map((v) => v == null ? "null" : v.toString());
+    var args = invocation.positionalArguments.map((v) => '$v');
     if (args.any((arg) => arg.contains('\n'))) {
       // As one or more arg contains newlines, put each on its own line, and
       // indent each, for better readability.
@@ -649,18 +650,18 @@
     if (!never && matchingInvocations.isEmpty) {
       var message;
       if (mock._realCalls.isEmpty) {
-        message = "No matching calls (actually, no calls at all).";
+        message = 'No matching calls (actually, no calls at all).';
       } else {
         var otherCalls = mock._realCallsToString();
-        message = "No matching calls. All calls: $otherCalls";
+        message = 'No matching calls. All calls: $otherCalls';
       }
-      fail("$message\n"
-          "(If you called `verify(...).called(0);`, please instead use "
-          "`verifyNever(...);`.)");
+      fail('$message\n'
+          '(If you called `verify(...).called(0);`, please instead use '
+          '`verifyNever(...);`.)');
     }
     if (never && matchingInvocations.isNotEmpty) {
       var calls = mock._realCallsToString();
-      fail("Unexpected calls. All calls: $calls");
+      fail('Unexpected calls. All calls: $calls');
     }
     matchingInvocations.forEach((inv) {
       inv.verified = true;
@@ -873,7 +874,7 @@
       _checkTestApiMismatch();
     }
     expect(callCount, wrapMatcher(matcher),
-        reason: "Unexpected number of calls");
+        reason: 'Unexpected number of calls');
   }
 }
 
@@ -939,12 +940,12 @@
   return <T>(T mock) {
     _verificationInProgress = false;
     if (_verifyCalls.length == 1) {
-      _VerifyCall verifyCall = _verifyCalls.removeLast();
+      var verifyCall = _verifyCalls.removeLast();
       var result = VerificationResult._(verifyCall.matchingInvocations.length);
       verifyCall._checkWith(never);
       return result;
     } else {
-      fail("Used on a non-mockito object");
+      fail('Used on a non-mockito object');
     }
   };
 }
@@ -970,23 +971,22 @@
   _verificationInProgress = true;
   return <T>(List<T> _) {
     _verificationInProgress = false;
-    DateTime dt = DateTime.fromMillisecondsSinceEpoch(0);
+    var dt = DateTime.fromMillisecondsSinceEpoch(0);
     var tmpVerifyCalls = List<_VerifyCall>.from(_verifyCalls);
     _verifyCalls.clear();
-    List<RealCall> matchedCalls = [];
-    for (_VerifyCall verifyCall in tmpVerifyCalls) {
-      RealCall matched = verifyCall._findAfter(dt);
+    var matchedCalls = <RealCall>[];
+    for (var verifyCall in tmpVerifyCalls) {
+      var matched = verifyCall._findAfter(dt);
       if (matched != null) {
         matchedCalls.add(matched);
         dt = matched.timeStamp;
       } else {
-        Set<Mock> mocks =
-            tmpVerifyCalls.map((_VerifyCall vc) => vc.mock).toSet();
-        List<RealCall> allInvocations =
+        var mocks = tmpVerifyCalls.map((vc) => vc.mock).toSet();
+        var allInvocations =
             mocks.expand((m) => m._realCalls).toList(growable: false);
         allInvocations
             .sort((inv1, inv2) => inv1.timeStamp.compareTo(inv2.timeStamp));
-        String otherCalls = "";
+        var otherCalls = '';
         if (allInvocations.isNotEmpty) {
           otherCalls = " All calls: ${allInvocations.join(", ")}";
         }
@@ -1011,7 +1011,7 @@
   if (mock is Mock) {
     var unverified = mock._realCalls.where((inv) => !inv.verified).toList();
     if (unverified.isNotEmpty) {
-      fail("No more calls expected, but following found: " + unverified.join());
+      fail('No more calls expected, but following found: ' + unverified.join());
     }
   } else {
     _throwMockArgumentError('verifyNoMoreInteractions', mock);
@@ -1021,7 +1021,7 @@
 void verifyZeroInteractions(var mock) {
   if (mock is Mock) {
     if (mock._realCalls.isNotEmpty) {
-      fail("No interaction expected, but following found: " +
+      fail('No interaction expected, but following found: ' +
           mock._realCalls.join());
     }
   } else {
@@ -1084,7 +1084,7 @@
 
 /// Print all collected invocations of any mock methods of [mocks].
 void logInvocations(List<Mock> mocks) {
-  List<RealCall> allInvocations =
+  var allInvocations =
       mocks.expand((m) => m._realCalls).toList(growable: false);
   allInvocations.sort((inv1, inv2) => inv1.timeStamp.compareTo(inv2.timeStamp));
   allInvocations.forEach((inv) {
diff --git a/pubspec.yaml b/pubspec.yaml
index b291b6d..1f438d9 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: mockito
-version: 4.1.1
+version: 4.1.2-dev
 
 authors:
   - Dmitriy Fibulwinter <fibulwinter@gmail.com>
diff --git a/test/capture_test.dart b/test/capture_test.dart
index 09da045..7c597ba 100644
--- a/test/capture_test.dart
+++ b/test/capture_test.dart
@@ -22,7 +22,7 @@
   String methodWithNormalArgs(int x) => 'Real';
   String methodWithListArgs(List<int> x) => 'Real';
   String methodWithPositionalArgs(int x, [int y]) => 'Real';
-  String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
+  String methodWithTwoNamedArgs(int x, {int y, int z}) => 'Real';
   set setter(String arg) {
     throw StateError('I must be mocked');
   }
diff --git a/test/deprecated_apis/mockito_test.dart b/test/deprecated_apis/mockito_test.dart
index 95dbcb4..ab9a4e3 100644
--- a/test/deprecated_apis/mockito_test.dart
+++ b/test/deprecated_apis/mockito_test.dart
@@ -24,18 +24,18 @@
 
 class _RealClass {
   _RealClass innerObj;
-  String methodWithoutArgs() => "Real";
-  String methodWithNormalArgs(int x) => "Real";
-  String methodWithListArgs(List<int> x) => "Real";
-  String methodWithPositionalArgs(int x, [int y]) => "Real";
-  String methodWithNamedArgs(int x, {int y}) => "Real";
-  String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
-  String methodWithObjArgs(_RealClass x) => "Real";
-  Future<String> methodReturningFuture() => Future.value("Real");
-  Stream<String> methodReturningStream() => Stream.fromIterable(["Real"]);
-  String get getter => "Real";
+  String methodWithoutArgs() => 'Real';
+  String methodWithNormalArgs(int x) => 'Real';
+  String methodWithListArgs(List<int> x) => 'Real';
+  String methodWithPositionalArgs(int x, [int y]) => 'Real';
+  String methodWithNamedArgs(int x, {int y}) => 'Real';
+  String methodWithTwoNamedArgs(int x, {int y, int z}) => 'Real';
+  String methodWithObjArgs(_RealClass x) => 'Real';
+  Future<String> methodReturningFuture() => Future.value('Real');
+  Stream<String> methodReturningStream() => Stream.fromIterable(['Real']);
+  String get getter => 'Real';
   set setter(String arg) {
-    throw StateError("I must be mocked");
+    throw StateError('I must be mocked');
   }
 }
 
@@ -54,23 +54,23 @@
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(String expectedMessage, dynamic expectedToFail()) {
+void expectFail(String expectedMessage, void Function() expectedToFail) {
   try {
     expectedToFail();
-    fail("It was expected to fail!");
+    fail('It was expected to fail!');
   } catch (e) {
     if (!(e is TestFailure)) {
       rethrow;
     } else {
       if (expectedMessage != e.message) {
-        throw TestFailure("Failed, but with wrong message: ${e.message}");
+        throw TestFailure('Failed, but with wrong message: ${e.message}');
       }
     }
   }
 }
 
-String noMatchingCallsFooter = "(If you called `verify(...).called(0);`, "
-    "please instead use `verifyNever(...);`.)";
+String noMatchingCallsFooter = '(If you called `verify(...).called(0);`, '
+    'please instead use `verifyNever(...);`.)';
 
 void main() {
   _MockedClass mock;
@@ -85,67 +85,67 @@
     resetMockitoState();
   });
 
-  group("when()", () {
-    test("should mock method with argument matcher", () {
+  group('when()', () {
+    test('should mock method with argument matcher', () {
       when(mock.methodWithNormalArgs(typed(argThat(greaterThan(100)))))
-          .thenReturn("A lot!");
+          .thenReturn('A lot!');
       expect(mock.methodWithNormalArgs(100), isNull);
-      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
+      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
     });
 
-    test("should mock method with any argument matcher", () {
-      when(mock.methodWithNormalArgs(typed(any))).thenReturn("A lot!");
-      expect(mock.methodWithNormalArgs(100), equals("A lot!"));
-      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
+    test('should mock method with any argument matcher', () {
+      when(mock.methodWithNormalArgs(typed(any))).thenReturn('A lot!');
+      expect(mock.methodWithNormalArgs(100), equals('A lot!'));
+      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
     });
 
-    test("should mock method with any list argument matcher", () {
-      when(mock.methodWithListArgs(typed(any))).thenReturn("A lot!");
-      expect(mock.methodWithListArgs([42]), equals("A lot!"));
-      expect(mock.methodWithListArgs([43]), equals("A lot!"));
+    test('should mock method with any list argument matcher', () {
+      when(mock.methodWithListArgs(typed(any))).thenReturn('A lot!');
+      expect(mock.methodWithListArgs([42]), equals('A lot!'));
+      expect(mock.methodWithListArgs([43]), equals('A lot!'));
     });
 
-    test("should mock method with mix of argument matchers and real things",
+    test('should mock method with mix of argument matchers and real things',
         () {
       when(mock.methodWithPositionalArgs(typed(argThat(greaterThan(100))), 17))
-          .thenReturn("A lot with 17");
+          .thenReturn('A lot with 17');
       expect(mock.methodWithPositionalArgs(100, 17), isNull);
       expect(mock.methodWithPositionalArgs(101, 18), isNull);
-      expect(mock.methodWithPositionalArgs(101, 17), equals("A lot with 17"));
+      expect(mock.methodWithPositionalArgs(101, 17), equals('A lot with 17'));
     });
 
     //no need to mock setter, except if we will have spies later...
-    test("should mock method with thrown result", () {
+    test('should mock method with thrown result', () {
       when(mock.methodWithNormalArgs(typed(any))).thenThrow(StateError('Boo'));
       expect(() => mock.methodWithNormalArgs(42), throwsStateError);
     });
 
-    test("should mock method with calculated result", () {
+    test('should mock method with calculated result', () {
       when(mock.methodWithNormalArgs(typed(any))).thenAnswer(
           (Invocation inv) => inv.positionalArguments[0].toString());
-      expect(mock.methodWithNormalArgs(43), equals("43"));
-      expect(mock.methodWithNormalArgs(42), equals("42"));
+      expect(mock.methodWithNormalArgs(43), equals('43'));
+      expect(mock.methodWithNormalArgs(42), equals('42'));
     });
 
-    test("should mock method with calculated result", () {
+    test('should mock method with calculated result', () {
       when(mock.methodWithNormalArgs(typed(argThat(equals(43)))))
-          .thenReturn("43");
+          .thenReturn('43');
       when(mock.methodWithNormalArgs(typed(argThat(equals(42)))))
-          .thenReturn("42");
-      expect(mock.methodWithNormalArgs(43), equals("43"));
+          .thenReturn('42');
+      expect(mock.methodWithNormalArgs(43), equals('43'));
     });
 
-    test("should mock hashCode", () {
+    test('should mock hashCode', () {
       named(mock, hashCode: 42);
       expect(mock.hashCode, equals(42));
     });
 
-    test("should have toString as name when it is not mocked", () {
-      named(mock, name: "Cat");
-      expect(mock.toString(), equals("Cat"));
+    test('should have toString as name when it is not mocked', () {
+      named(mock, name: 'Cat');
+      expect(mock.toString(), equals('Cat'));
     });
 
-    test("should mock equals between mocks when givenHashCode is equals", () {
+    test('should mock equals between mocks when givenHashCode is equals', () {
       var anotherMock = named(_MockedClass(), hashCode: 42);
       named(mock, hashCode: 42);
       expect(mock == anotherMock, isTrue);
diff --git a/test/deprecated_apis/until_called_test.dart b/test/deprecated_apis/until_called_test.dart
index 92ed487..f4e6801 100644
--- a/test/deprecated_apis/until_called_test.dart
+++ b/test/deprecated_apis/until_called_test.dart
@@ -86,8 +86,7 @@
   });
 
   group('untilCalled', () {
-    StreamController<CallMethodsEvent> streamController =
-        StreamController.broadcast();
+    var streamController = StreamController<CallMethodsEvent>.broadcast();
 
     group('on methods already called', () {
       test('waits for method with normal args', () async {
diff --git a/test/deprecated_apis/verify_test.dart b/test/deprecated_apis/verify_test.dart
index a8c870c..74cfdcb 100644
--- a/test/deprecated_apis/verify_test.dart
+++ b/test/deprecated_apis/verify_test.dart
@@ -57,7 +57,7 @@
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(String expectedMessage, dynamic expectedToFail()) {
+void expectFail(String expectedMessage, void Function() expectedToFail) {
   try {
     expectedToFail();
     fail('It was expected to fail!');
diff --git a/test/invocation_matcher_test.dart b/test/invocation_matcher_test.dart
index 12eae07..dc5bb52 100644
--- a/test/invocation_matcher_test.dart
+++ b/test/invocation_matcher_test.dart
@@ -66,9 +66,9 @@
       shouldFail(
         call1,
         isInvocation(call3),
-        "Expected: lie(<false>) "
+        'Expected: lie(<false>) '
         "Actual: <Instance of '${call3.runtimeType}'> "
-        "Which: Does not match lie(<true>)",
+        'Which: Does not match lie(<true>)',
       );
     });
 
@@ -102,9 +102,9 @@
         call1,
         isInvocation(call3),
         // RegExp needed because of https://github.com/dart-lang/sdk/issues/33565
-        RegExp("Expected: set value=? <false> "
+        RegExp('Expected: set value=? <false> '
             "Actual: <Instance of '${call3.runtimeType}'> "
-            "Which: Does not match set value=? <true>"),
+            'Which: Does not match set value=? <true>'),
       );
     });
   });
@@ -118,7 +118,7 @@
       shouldFail(
         call,
         invokes(#say, positionalArguments: [isNull]),
-        "Expected: say(null) "
+        'Expected: say(null) '
         "Actual: <Instance of '${call.runtimeType}'> "
         "Which: Does not match say('Hello')",
       );
diff --git a/test/mockito_test.dart b/test/mockito_test.dart
index 3ac032b..e31cde2 100644
--- a/test/mockito_test.dart
+++ b/test/mockito_test.dart
@@ -21,16 +21,16 @@
 
 class _RealClass {
   _RealClass innerObj;
-  String methodWithoutArgs() => "Real";
-  String methodWithNormalArgs(int x) => "Real";
-  String methodWithListArgs(List<int> x) => "Real";
-  String methodWithPositionalArgs(int x, [int y]) => "Real";
-  String methodWithNamedArgs(int x, {int y}) => "Real";
-  String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
-  String methodWithObjArgs(_RealClass x) => "Real";
-  Future<String> methodReturningFuture() => Future.value("Real");
-  Stream<String> methodReturningStream() => Stream.fromIterable(["Real"]);
-  String get getter => "Real";
+  String methodWithoutArgs() => 'Real';
+  String methodWithNormalArgs(int x) => 'Real';
+  String methodWithListArgs(List<int> x) => 'Real';
+  String methodWithPositionalArgs(int x, [int y]) => 'Real';
+  String methodWithNamedArgs(int x, {int y}) => 'Real';
+  String methodWithTwoNamedArgs(int x, {int y, int z}) => 'Real';
+  String methodWithObjArgs(_RealClass x) => 'Real';
+  Future<String> methodReturningFuture() => Future.value('Real');
+  Stream<String> methodReturningStream() => Stream.fromIterable(['Real']);
+  String get getter => 'Real';
 }
 
 abstract class _Foo {
@@ -43,30 +43,30 @@
 
   String baz();
 
-  String quux() => "Real";
+  String quux() => 'Real';
 }
 
 class _MockFoo extends _AbstractFoo with Mock {}
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(String expectedMessage, dynamic expectedToFail()) {
+void expectFail(String expectedMessage, void Function() expectedToFail) {
   try {
     expectedToFail();
-    fail("It was expected to fail!");
+    fail('It was expected to fail!');
   } catch (e) {
     if (!(e is TestFailure)) {
       rethrow;
     } else {
       if (expectedMessage != e.message) {
-        throw TestFailure("Failed, but with wrong message: ${e.message}");
+        throw TestFailure('Failed, but with wrong message: ${e.message}');
       }
     }
   }
 }
 
-String noMatchingCallsFooter = "(If you called `verify(...).called(0);`, "
-    "please instead use `verifyNever(...);`.)";
+String noMatchingCallsFooter = '(If you called `verify(...).called(0);`, '
+    'please instead use `verifyNever(...);`.)';
 
 void main() {
   _MockedClass mock;
@@ -83,229 +83,229 @@
     resetMockitoState();
   });
 
-  group("mixin support", () {
-    test("should work", () {
+  group('mixin support', () {
+    test('should work', () {
       var foo = _MockFoo();
       when(foo.baz()).thenReturn('baz');
       expect(foo.bar(), 'baz');
     });
   });
 
-  group("when()", () {
-    test("should mock method without args", () {
-      when(mock.methodWithoutArgs()).thenReturn("A");
-      expect(mock.methodWithoutArgs(), equals("A"));
+  group('when()', () {
+    test('should mock method without args', () {
+      when(mock.methodWithoutArgs()).thenReturn('A');
+      expect(mock.methodWithoutArgs(), equals('A'));
     });
 
-    test("should mock method with normal args", () {
-      when(mock.methodWithNormalArgs(42)).thenReturn("Ultimate Answer");
+    test('should mock method with normal args', () {
+      when(mock.methodWithNormalArgs(42)).thenReturn('Ultimate Answer');
       expect(mock.methodWithNormalArgs(43), isNull);
-      expect(mock.methodWithNormalArgs(42), equals("Ultimate Answer"));
+      expect(mock.methodWithNormalArgs(42), equals('Ultimate Answer'));
     });
 
-    test("should mock method with mock args", () {
+    test('should mock method with mock args', () {
       var m1 = _MockedClass();
-      when(mock.methodWithObjArgs(m1)).thenReturn("Ultimate Answer");
+      when(mock.methodWithObjArgs(m1)).thenReturn('Ultimate Answer');
       expect(mock.methodWithObjArgs(_MockedClass()), isNull);
-      expect(mock.methodWithObjArgs(m1), equals("Ultimate Answer"));
+      expect(mock.methodWithObjArgs(m1), equals('Ultimate Answer'));
     });
 
-    test("should mock method with positional args", () {
-      when(mock.methodWithPositionalArgs(42, 17)).thenReturn("Answer and...");
+    test('should mock method with positional args', () {
+      when(mock.methodWithPositionalArgs(42, 17)).thenReturn('Answer and...');
       expect(mock.methodWithPositionalArgs(42), isNull);
       expect(mock.methodWithPositionalArgs(42, 18), isNull);
-      expect(mock.methodWithPositionalArgs(42, 17), equals("Answer and..."));
+      expect(mock.methodWithPositionalArgs(42, 17), equals('Answer and...'));
     });
 
-    test("should mock method with named args", () {
-      when(mock.methodWithNamedArgs(42, y: 17)).thenReturn("Why answer?");
+    test('should mock method with named args', () {
+      when(mock.methodWithNamedArgs(42, y: 17)).thenReturn('Why answer?');
       expect(mock.methodWithNamedArgs(42), isNull);
       expect(mock.methodWithNamedArgs(42, y: 18), isNull);
-      expect(mock.methodWithNamedArgs(42, y: 17), equals("Why answer?"));
+      expect(mock.methodWithNamedArgs(42, y: 17), equals('Why answer?'));
     });
 
-    test("should mock method with List args", () {
-      when(mock.methodWithListArgs([42])).thenReturn("Ultimate answer");
+    test('should mock method with List args', () {
+      when(mock.methodWithListArgs([42])).thenReturn('Ultimate answer');
       expect(mock.methodWithListArgs([43]), isNull);
-      expect(mock.methodWithListArgs([42]), equals("Ultimate answer"));
+      expect(mock.methodWithListArgs([42]), equals('Ultimate answer'));
     });
 
-    test("should mock method with argument matcher", () {
+    test('should mock method with argument matcher', () {
       when(mock.methodWithNormalArgs(argThat(greaterThan(100))))
-          .thenReturn("A lot!");
+          .thenReturn('A lot!');
       expect(mock.methodWithNormalArgs(100), isNull);
-      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
+      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
     });
 
-    test("should mock method with any argument matcher", () {
-      when(mock.methodWithNormalArgs(any)).thenReturn("A lot!");
-      expect(mock.methodWithNormalArgs(100), equals("A lot!"));
-      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
+    test('should mock method with any argument matcher', () {
+      when(mock.methodWithNormalArgs(any)).thenReturn('A lot!');
+      expect(mock.methodWithNormalArgs(100), equals('A lot!'));
+      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
     });
 
-    test("should mock method with any list argument matcher", () {
-      when(mock.methodWithListArgs(any)).thenReturn("A lot!");
-      expect(mock.methodWithListArgs([42]), equals("A lot!"));
-      expect(mock.methodWithListArgs([43]), equals("A lot!"));
+    test('should mock method with any list argument matcher', () {
+      when(mock.methodWithListArgs(any)).thenReturn('A lot!');
+      expect(mock.methodWithListArgs([42]), equals('A lot!'));
+      expect(mock.methodWithListArgs([43]), equals('A lot!'));
     });
 
-    test("should mock method with multiple named args and matchers", () {
+    test('should mock method with multiple named args and matchers', () {
       when(mock.methodWithTwoNamedArgs(any, y: anyNamed('y')))
-          .thenReturn("x y");
+          .thenReturn('x y');
       when(mock.methodWithTwoNamedArgs(any, z: anyNamed('z')))
-          .thenReturn("x z");
+          .thenReturn('x z');
       if (isNsmForwarding) {
-        expect(mock.methodWithTwoNamedArgs(42), "x z");
+        expect(mock.methodWithTwoNamedArgs(42), 'x z');
       } else {
         expect(mock.methodWithTwoNamedArgs(42), isNull);
       }
-      expect(mock.methodWithTwoNamedArgs(42, y: 18), equals("x y"));
-      expect(mock.methodWithTwoNamedArgs(42, z: 17), equals("x z"));
+      expect(mock.methodWithTwoNamedArgs(42, y: 18), equals('x y'));
+      expect(mock.methodWithTwoNamedArgs(42, z: 17), equals('x z'));
       expect(mock.methodWithTwoNamedArgs(42, y: 18, z: 17), isNull);
       when(mock.methodWithTwoNamedArgs(any, y: anyNamed('y'), z: anyNamed('z')))
-          .thenReturn("x y z");
-      expect(mock.methodWithTwoNamedArgs(42, y: 18, z: 17), equals("x y z"));
+          .thenReturn('x y z');
+      expect(mock.methodWithTwoNamedArgs(42, y: 18, z: 17), equals('x y z'));
     });
 
-    test("should mock method with mix of argument matchers and real things",
+    test('should mock method with mix of argument matchers and real things',
         () {
       when(mock.methodWithPositionalArgs(argThat(greaterThan(100)), 17))
-          .thenReturn("A lot with 17");
+          .thenReturn('A lot with 17');
       expect(mock.methodWithPositionalArgs(100, 17), isNull);
       expect(mock.methodWithPositionalArgs(101, 18), isNull);
-      expect(mock.methodWithPositionalArgs(101, 17), equals("A lot with 17"));
+      expect(mock.methodWithPositionalArgs(101, 17), equals('A lot with 17'));
     });
 
-    test("should mock getter", () {
-      when(mock.getter).thenReturn("A");
-      expect(mock.getter, equals("A"));
+    test('should mock getter', () {
+      when(mock.getter).thenReturn('A');
+      expect(mock.getter, equals('A'));
     });
 
-    test("should have hashCode when it is not mocked", () {
+    test('should have hashCode when it is not mocked', () {
       expect(mock.hashCode, isNotNull);
     });
 
-    test("should have default toString when it is not mocked", () {
-      expect(mock.toString(), equals("_MockedClass"));
+    test('should have default toString when it is not mocked', () {
+      expect(mock.toString(), equals('_MockedClass'));
     });
 
-    test("should use identical equality between it is not mocked", () {
+    test('should use identical equality between it is not mocked', () {
       var anotherMock = _MockedClass();
       expect(mock == anotherMock, isFalse);
       expect(mock == mock, isTrue);
     });
 
-    test("should mock method with thrown result", () {
+    test('should mock method with thrown result', () {
       when(mock.methodWithNormalArgs(any)).thenThrow(StateError('Boo'));
       expect(() => mock.methodWithNormalArgs(42), throwsStateError);
     });
 
-    test("should mock method with calculated result", () {
+    test('should mock method with calculated result', () {
       when(mock.methodWithNormalArgs(any)).thenAnswer(
           (Invocation inv) => inv.positionalArguments[0].toString());
-      expect(mock.methodWithNormalArgs(43), equals("43"));
-      expect(mock.methodWithNormalArgs(42), equals("42"));
+      expect(mock.methodWithNormalArgs(43), equals('43'));
+      expect(mock.methodWithNormalArgs(42), equals('42'));
     });
 
-    test("should return mock to make simple oneline mocks", () {
+    test('should return mock to make simple oneline mocks', () {
       _RealClass mockWithSetup = _MockedClass();
-      when(mockWithSetup.methodWithoutArgs()).thenReturn("oneline");
-      expect(mockWithSetup.methodWithoutArgs(), equals("oneline"));
+      when(mockWithSetup.methodWithoutArgs()).thenReturn('oneline');
+      expect(mockWithSetup.methodWithoutArgs(), equals('oneline'));
     });
 
-    test("should use latest matching when definition", () {
-      when(mock.methodWithoutArgs()).thenReturn("A");
-      when(mock.methodWithoutArgs()).thenReturn("B");
-      expect(mock.methodWithoutArgs(), equals("B"));
+    test('should use latest matching when definition', () {
+      when(mock.methodWithoutArgs()).thenReturn('A');
+      when(mock.methodWithoutArgs()).thenReturn('B');
+      expect(mock.methodWithoutArgs(), equals('B'));
     });
 
-    test("should mock method with calculated result", () {
-      when(mock.methodWithNormalArgs(argThat(equals(43)))).thenReturn("43");
-      when(mock.methodWithNormalArgs(argThat(equals(42)))).thenReturn("42");
-      expect(mock.methodWithNormalArgs(43), equals("43"));
+    test('should mock method with calculated result', () {
+      when(mock.methodWithNormalArgs(argThat(equals(43)))).thenReturn('43');
+      when(mock.methodWithNormalArgs(argThat(equals(42)))).thenReturn('42');
+      expect(mock.methodWithNormalArgs(43), equals('43'));
     });
 
     // Error path tests.
-    test("should throw if `when` is called while stubbing", () {
+    test('should throw if `when` is called while stubbing', () {
       expect(() {
         var responseHelper = () {
           var mock2 = _MockedClass();
-          when(mock2.getter).thenReturn("A");
+          when(mock2.getter).thenReturn('A');
           return mock2;
         };
         when(mock.innerObj).thenReturn(responseHelper());
       }, throwsStateError);
     });
 
-    test("thenReturn throws if provided Future", () {
+    test('thenReturn throws if provided Future', () {
       expect(
           () => when(mock.methodReturningFuture())
-              .thenReturn(Future.value("stub")),
+              .thenReturn(Future.value('stub')),
           throwsArgumentError);
     });
 
-    test("thenReturn throws if provided Stream", () {
+    test('thenReturn throws if provided Stream', () {
       expect(
           () => when(mock.methodReturningStream())
-              .thenReturn(Stream.fromIterable(["stub"])),
+              .thenReturn(Stream.fromIterable(['stub'])),
           throwsArgumentError);
     });
 
-    test("thenAnswer supports stubbing method returning a Future", () async {
+    test('thenAnswer supports stubbing method returning a Future', () async {
       when(mock.methodReturningFuture())
-          .thenAnswer((_) => Future.value("stub"));
+          .thenAnswer((_) => Future.value('stub'));
 
-      expect(await mock.methodReturningFuture(), "stub");
+      expect(await mock.methodReturningFuture(), 'stub');
     });
 
-    test("thenAnswer supports stubbing method returning a Stream", () async {
+    test('thenAnswer supports stubbing method returning a Stream', () async {
       when(mock.methodReturningStream())
-          .thenAnswer((_) => Stream.fromIterable(["stub"]));
+          .thenAnswer((_) => Stream.fromIterable(['stub']));
 
-      expect(await mock.methodReturningStream().toList(), ["stub"]);
+      expect(await mock.methodReturningStream().toList(), ['stub']);
     });
 
-    test("should throw if named matcher is passed as the wrong name", () {
+    test('should throw if named matcher is passed as the wrong name', () {
       expect(() {
-        when(mock.methodWithNamedArgs(argThat(equals(42)), y: anyNamed("z")))
-            .thenReturn("99");
+        when(mock.methodWithNamedArgs(argThat(equals(42)), y: anyNamed('z')))
+            .thenReturn('99');
       }, throwsArgumentError);
     });
 
-    test("should throw if attempting to stub a real method", () {
+    test('should throw if attempting to stub a real method', () {
       var foo = _MockFoo();
       expect(() {
-        when(foo.quux()).thenReturn("Stub");
+        when(foo.quux()).thenReturn('Stub');
       }, throwsStateError);
     });
   });
 
-  group("throwOnMissingStub", () {
-    test("should throw when a mock was called without a matching stub", () {
+  group('throwOnMissingStub', () {
+    test('should throw when a mock was called without a matching stub', () {
       throwOnMissingStub(mock);
-      when(mock.methodWithNormalArgs(42)).thenReturn("Ultimate Answer");
+      when(mock.methodWithNormalArgs(42)).thenReturn('Ultimate Answer');
       expect(
         () => (mock).methodWithoutArgs(),
         throwsNoSuchMethodError,
       );
     });
 
-    test("should not throw when a mock was called with a matching stub", () {
+    test('should not throw when a mock was called with a matching stub', () {
       throwOnMissingStub(mock);
-      when(mock.methodWithoutArgs()).thenReturn("A");
+      when(mock.methodWithoutArgs()).thenReturn('A');
       expect(() => mock.methodWithoutArgs(), returnsNormally);
     });
   });
 
   test(
-      "reports an error when using an argument matcher outside of stubbing or "
-      "verification", () {
+      'reports an error when using an argument matcher outside of stubbing or '
+      'verification', () {
     expect(() => mock.methodWithNormalArgs(any), throwsArgumentError);
   });
 
   test(
-      "reports an error when using an argument matcher in a position other "
-      "than an argument for the stubbed method", () {
+      'reports an error when using an argument matcher in a position other '
+      'than an argument for the stubbed method', () {
     expect(() => when(mock.methodWithListArgs(List.filled(7, any))),
         throwsArgumentError);
   });
diff --git a/test/until_called_test.dart b/test/until_called_test.dart
index 634c59c..4a0b03f 100644
--- a/test/until_called_test.dart
+++ b/test/until_called_test.dart
@@ -81,8 +81,7 @@
   });
 
   group('untilCalled', () {
-    StreamController<CallMethodsEvent> streamController =
-        StreamController.broadcast();
+    var streamController = StreamController<CallMethodsEvent>.broadcast();
 
     group('on methods already called', () {
       test('waits for method without args', () async {
diff --git a/test/verify_test.dart b/test/verify_test.dart
index 0c41c29..7622a2b 100644
--- a/test/verify_test.dart
+++ b/test/verify_test.dart
@@ -54,7 +54,7 @@
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(Pattern expectedMessage, dynamic expectedToFail()) {
+void expectFail(Pattern expectedMessage, void Function() expectedToFail) {
   try {
     expectedToFail();
     fail('It was expected to fail!');