diff --git a/test/capture_test.dart b/test/capture_test.dart
new file mode 100644
index 0000000..13ab95a
--- /dev/null
+++ b/test/capture_test.dart
@@ -0,0 +1,98 @@
+// Copyright 2018 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.
+
+import 'package:mockito/mockito.dart';
+import 'package:mockito/src/mock.dart' show resetMockitoState;
+import 'package:test/test.dart';
+
+class RealClass {
+  RealClass innerObj;
+  String methodWithNormalArgs(int x) => 'Real';
+  String methodWithListArgs(List<int> x) => 'Real';
+  String methodWithPositionalArgs(int x, [int y]) => 'Real';
+  set setter(String arg) {
+    throw new StateError('I must be mocked');
+  }
+}
+
+class MockedClass extends Mock implements RealClass {}
+
+void main() {
+  MockedClass mock;
+
+  setUp(() {
+    mock = new MockedClass();
+  });
+
+  tearDown(() {
+    // In some of the tests that expect an Error to be thrown, Mockito's
+    // global state can become invalid. Reset it.
+    resetMockitoState();
+  });
+
+  group('capture', () {
+    test('captureAny should match anything', () {
+      mock.methodWithNormalArgs(42);
+      expect(
+          verify(mock.methodWithNormalArgs(typed(captureAny))).captured.single,
+          equals(42));
+    });
+
+    test('captureThat should match some things', () {
+      mock.methodWithNormalArgs(42);
+      mock.methodWithNormalArgs(44);
+      mock.methodWithNormalArgs(43);
+      mock.methodWithNormalArgs(45);
+      expect(
+          verify(mock.methodWithNormalArgs(typed(captureThat(lessThan(44)))))
+              .captured,
+          equals([42, 43]));
+    });
+
+    test('should capture list arguments', () {
+      mock.methodWithListArgs([42]);
+      expect(verify(mock.methodWithListArgs(typed(captureAny))).captured.single,
+          equals([42]));
+    });
+
+    test('should capture multiple arguments', () {
+      mock.methodWithPositionalArgs(1, 2);
+      expect(
+          verify(mock.methodWithPositionalArgs(
+                  typed(captureAny), typed(captureAny)))
+              .captured,
+          equals([1, 2]));
+    });
+
+    test('should capture with matching arguments', () {
+      mock.methodWithPositionalArgs(1);
+      mock.methodWithPositionalArgs(2, 3);
+      expect(
+          verify(mock.methodWithPositionalArgs(
+                  typed(captureAny), typed(captureAny)))
+              .captured,
+          equals([2, 3]));
+    });
+
+    test('should capture multiple invocations', () {
+      mock.methodWithNormalArgs(1);
+      mock.methodWithNormalArgs(2);
+      expect(verify(mock.methodWithNormalArgs(typed(captureAny))).captured,
+          equals([1, 2]));
+    });
+  });
+
+  // TODO(srawlins): Test capturing in a setter.
+  // TODO(srawlins): Test capturing named arguments.
+}
diff --git a/test/mockito_test.dart b/test/mockito_test.dart
index f377720..49946d7 100644
--- a/test/mockito_test.dart
+++ b/test/mockito_test.dart
@@ -30,49 +30,12 @@
   String methodWithObjArgs(RealClass x) => "Real";
   Future<String> methodReturningFuture() => new Future.value("Real");
   Stream<String> methodReturningStream() => new Stream.fromIterable(["Real"]);
-  // "SpecialArgs" here means type-parameterized args. But that makes for a long
-  // method name.
-  String typeParameterizedFn(List<int> w, List<int> x,
-          [List<int> y, List<int> z]) =>
-      "Real";
-  // "SpecialNamedArgs" here means type-parameterized, named args. But that
-  // makes for a long method name.
-  String typeParameterizedNamedFn(List<int> w, List<int> x,
-          {List<int> y, List<int> z}) =>
-      "Real";
   String get getter => "Real";
   set setter(String arg) {
     throw new StateError("I must be mocked");
   }
 }
 
-class CallMethodsEvent {}
-
-/// Listens on a stream and upon any event calls all methods in [RealClass].
-class RealClassController {
-  final RealClass _realClass;
-
-  RealClassController(
-      this._realClass, StreamController<CallMethodsEvent> streamController) {
-    streamController.stream.listen(_callAllMethods);
-  }
-
-  Future<Null> _callAllMethods(_) async {
-    _realClass
-      ..methodWithoutArgs()
-      ..methodWithNormalArgs(1)
-      ..methodWithListArgs([1, 2])
-      ..methodWithPositionalArgs(1, 2)
-      ..methodWithNamedArgs(1, y: 2)
-      ..methodWithTwoNamedArgs(1, y: 2, z: 3)
-      ..methodWithObjArgs(new RealClass())
-      ..typeParameterizedFn([1, 2], [3, 4], [5, 6], [7, 8])
-      ..typeParameterizedNamedFn([1, 2], [3, 4], y: [5, 6], z: [7, 8])
-      ..getter
-      ..setter = "A";
-  }
-}
-
 abstract class Foo {
   String bar();
 }
@@ -349,654 +312,6 @@
     });
   });
 
-  group("untilCalled", () {
-    StreamController<CallMethodsEvent> streamController =
-        new StreamController.broadcast();
-
-    group("on methods already called", () {
-      test("waits for method without args", () async {
-        mock.methodWithoutArgs();
-
-        await untilCalled(mock.methodWithoutArgs());
-
-        verify(mock.methodWithoutArgs()).called(1);
-      });
-
-      test("waits for method with normal args", () async {
-        mock.methodWithNormalArgs(1);
-
-        await untilCalled(mock.methodWithNormalArgs(typed(any)));
-
-        verify(mock.methodWithNormalArgs(typed(any))).called(1);
-      });
-
-      test("waits for method with list args", () async {
-        mock.methodWithListArgs([1]);
-
-        await untilCalled(mock.methodWithListArgs(typed(any)));
-
-        verify(mock.methodWithListArgs(typed(any))).called(1);
-      });
-
-      test("waits for method with positional args", () async {
-        mock.methodWithPositionalArgs(1, 2);
-
-        await untilCalled(
-            mock.methodWithPositionalArgs(typed(any), typed(any)));
-
-        verify(mock.methodWithPositionalArgs(typed(any), typed(any))).called(1);
-      });
-
-      test("waits for method with named args", () async {
-        mock.methodWithNamedArgs(1, y: 2);
-
-        await untilCalled(mock.methodWithNamedArgs(any, y: anyNamed('y')));
-
-        verify(mock.methodWithNamedArgs(any, y: anyNamed('y'))).called(1);
-      });
-
-      test("waits for method with two named args", () async {
-        mock.methodWithTwoNamedArgs(1, y: 2, z: 3);
-
-        await untilCalled(mock.methodWithTwoNamedArgs(any,
-            y: anyNamed('y'), z: anyNamed('z')));
-
-        verify(mock.methodWithTwoNamedArgs(any,
-                y: anyNamed('y'), z: anyNamed('z')))
-            .called(1);
-      });
-
-      test("waits for method with obj args", () async {
-        mock.methodWithObjArgs(new RealClass());
-
-        await untilCalled(mock.methodWithObjArgs(typed(any)));
-
-        verify(mock.methodWithObjArgs(typed(any))).called(1);
-      });
-
-      test("waits for function with positional parameters", () async {
-        mock.typeParameterizedFn([1, 2], [3, 4], [5, 6], [7, 8]);
-
-        await untilCalled(mock.typeParameterizedFn(
-            typed(any), typed(any), typed(any), typed(any)));
-
-        verify(mock.typeParameterizedFn(
-                typed(any), typed(any), typed(any), typed(any)))
-            .called(1);
-      });
-
-      test("waits for function with named parameters", () async {
-        mock.typeParameterizedNamedFn([1, 2], [3, 4], y: [5, 6], z: [7, 8]);
-
-        await untilCalled(mock.typeParameterizedNamedFn(any, any,
-            y: anyNamed('y'), z: anyNamed('z')));
-
-        verify(mock.typeParameterizedNamedFn(any, any,
-                y: anyNamed('y'), z: anyNamed('z')))
-            .called(1);
-      });
-
-      test("waits for getter", () async {
-        mock.getter;
-
-        await untilCalled(mock.getter);
-
-        verify(mock.getter).called(1);
-      });
-
-      test("waits for setter", () async {
-        mock.setter = "A";
-
-        await untilCalled(mock.setter = "A");
-
-        verify(mock.setter = "A").called(1);
-      });
-    });
-
-    group("on methods not yet called", () {
-      setUp(() {
-        new RealClassController(mock, streamController);
-      });
-
-      test("waits for method without args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithoutArgs());
-
-        await untilCalled(mock.methodWithoutArgs());
-
-        verify(mock.methodWithoutArgs()).called(1);
-      });
-
-      test("waits for method with normal args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithNormalArgs(typed(any)));
-
-        await untilCalled(mock.methodWithNormalArgs(typed(any)));
-
-        verify(mock.methodWithNormalArgs(typed(any))).called(1);
-      });
-
-      test("waits for method with list args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithListArgs(typed(any)));
-
-        await untilCalled(mock.methodWithListArgs(typed(any)));
-
-        verify(mock.methodWithListArgs(typed(any))).called(1);
-      });
-
-      test("waits for method with positional args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithPositionalArgs(typed(any), typed(any)));
-
-        await untilCalled(
-            mock.methodWithPositionalArgs(typed(any), typed(any)));
-
-        verify(mock.methodWithPositionalArgs(typed(any), typed(any))).called(1);
-      });
-
-      test("waits for method with named args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithNamedArgs(any, y: anyNamed('y')));
-
-        await untilCalled(mock.methodWithNamedArgs(any, y: anyNamed('y')));
-
-        verify(mock.methodWithNamedArgs(any, y: anyNamed('y'))).called(1);
-      });
-
-      test("waits for method with two named args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithTwoNamedArgs(any,
-            y: anyNamed('y'), z: anyNamed('z')));
-
-        await untilCalled(mock.methodWithTwoNamedArgs(any,
-            y: anyNamed('y'), z: anyNamed('z')));
-
-        verify(mock.methodWithTwoNamedArgs(any,
-                y: anyNamed('y'), z: anyNamed('z')))
-            .called(1);
-      });
-
-      test("waits for method with obj args", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.methodWithObjArgs(typed(any)));
-
-        await untilCalled(mock.methodWithObjArgs(typed(any)));
-
-        verify(mock.methodWithObjArgs(typed(any))).called(1);
-      });
-
-      test("waits for function with positional parameters", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.typeParameterizedFn(
-            typed(any), typed(any), typed(any), typed(any)));
-
-        await untilCalled(mock.typeParameterizedFn(
-            typed(any), typed(any), typed(any), typed(any)));
-
-        verify(mock.typeParameterizedFn(
-                typed(any), typed(any), typed(any), typed(any)))
-            .called(1);
-      });
-
-      test("waits for function with named parameters", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.typeParameterizedNamedFn(any, any,
-            y: anyNamed('y'), z: anyNamed('z')));
-
-        await untilCalled(mock.typeParameterizedNamedFn(any, any,
-            y: anyNamed('y'), z: anyNamed('z')));
-
-        verify(mock.typeParameterizedNamedFn(any, any,
-                y: anyNamed('y'), z: anyNamed('z')))
-            .called(1);
-      });
-
-      test("waits for getter", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.getter);
-
-        await untilCalled(mock.getter);
-
-        verify(mock.getter).called(1);
-      });
-
-      test("waits for setter", () async {
-        streamController.add(new CallMethodsEvent());
-        verifyNever(mock.setter = "A");
-
-        await untilCalled(mock.setter = "A");
-
-        verify(mock.setter = "A").called(1);
-      });
-    });
-  });
-
-  group("verify()", () {
-    test("should verify method without args", () {
-      mock.methodWithoutArgs();
-      verify(mock.methodWithoutArgs());
-    });
-
-    test("should verify method with normal args", () {
-      mock.methodWithNormalArgs(42);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithNormalArgs(42)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithNormalArgs(43));
-      });
-      verify(mock.methodWithNormalArgs(42));
-    });
-
-    test("should mock method with positional args", () {
-      mock.methodWithPositionalArgs(42, 17);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithPositionalArgs(42, 17)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithPositionalArgs(42));
-      });
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithPositionalArgs(42, 17)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithPositionalArgs(42, 18));
-      });
-      verify(mock.methodWithPositionalArgs(42, 17));
-    });
-
-    test("should mock method with named args", () {
-      mock.methodWithNamedArgs(42, y: 17);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithNamedArgs(42, {y: 17})\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithNamedArgs(42));
-      });
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithNamedArgs(42, {y: 17})\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithNamedArgs(42, y: 18));
-      });
-      verify(mock.methodWithNamedArgs(42, y: 17));
-    });
-
-    test("should mock method with mock args", () {
-      var m1 = named(new MockedClass(), name: "m1");
-      mock.methodWithObjArgs(m1);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithObjArgs(m1)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithObjArgs(new MockedClass()));
-      });
-      verify(mock.methodWithObjArgs(m1));
-    });
-
-    test("should mock method with list args", () {
-      mock.methodWithListArgs([42]);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithListArgs([42])\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithListArgs([43]));
-      });
-      verify(mock.methodWithListArgs([42]));
-    });
-
-    test("should mock method with argument matcher", () {
-      mock.methodWithNormalArgs(100);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithNormalArgs(100)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithNormalArgs(typed(argThat(greaterThan(100)))));
-      });
-      verify(
-          mock.methodWithNormalArgs(typed(argThat(greaterThanOrEqualTo(100)))));
-    });
-
-    test("should mock method with argument capturer", () {
-      mock.methodWithNormalArgs(50);
-      mock.methodWithNormalArgs(100);
-      expect(verify(mock.methodWithNormalArgs(typed(captureAny))).captured,
-          equals([50, 100]));
-    });
-
-    test("should mock method with argument matcher and capturer", () {
-      mock.methodWithNormalArgs(50);
-      mock.methodWithNormalArgs(100);
-      expect(
-          verify(mock.methodWithNormalArgs(typed(captureThat(greaterThan(75)))))
-              .captured
-              .single,
-          equals(100));
-      expect(
-          verify(mock.methodWithNormalArgs(typed(captureThat(lessThan(75)))))
-              .captured
-              .single,
-          equals(50));
-    });
-
-    test("should mock method with mix of argument matchers and real things",
-        () {
-      mock.methodWithPositionalArgs(100, 17);
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithPositionalArgs(100, 17)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithPositionalArgs(
-            typed(argThat(greaterThanOrEqualTo(100))), 18));
-      });
-      expectFail(
-          "No matching calls. All calls: MockedClass.methodWithPositionalArgs(100, 17)\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.methodWithPositionalArgs(
-            typed(argThat(greaterThan(100))), 17));
-      });
-      verify(mock.methodWithPositionalArgs(
-          typed(argThat(greaterThanOrEqualTo(100))), 17));
-    });
-
-    test("should mock getter", () {
-      mock.getter;
-      verify(mock.getter);
-    });
-
-    test("should mock setter", () {
-      mock.setter = "A";
-      expectFail(
-          "No matching calls. All calls: MockedClass.setter==A\n"
-          "$noMatchingCallsFooter", () {
-        verify(mock.setter = "B");
-      });
-      verify(mock.setter = "A");
-    });
-
-    test("should throw meaningful errors when verification is interrupted", () {
-      var badHelper = () => throw 'boo';
-      try {
-        verify(mock.methodWithNamedArgs(42, y: badHelper()));
-        fail("verify call was expected to throw!");
-      } catch (_) {}
-      // At this point, verification was interrupted, so
-      // `_verificationInProgress` is still `true`. Calling mock methods below
-      // adds items to `_verifyCalls`.
-      mock.methodWithNamedArgs(42, y: 17);
-      mock.methodWithNamedArgs(42, y: 17);
-      try {
-        verify(mock.methodWithNamedArgs(42, y: 17));
-        fail("verify call was expected to throw!");
-      } catch (e) {
-        expect(e, new isInstanceOf<StateError>());
-        expect(
-            e.message,
-            contains(
-                "Verification appears to be in progress. 2 verify calls have been stored."));
-      }
-    });
-  });
-
-  group("verify() qualifies", () {
-    group("unqualified as at least one", () {
-      test("zero fails", () {
-        expectFail(
-            "No matching calls (actually, no calls at all).\n"
-            "$noMatchingCallsFooter", () {
-          verify(mock.methodWithoutArgs());
-        });
-      });
-
-      test("one passes", () {
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs());
-      });
-
-      test("more than one passes", () {
-        mock.methodWithoutArgs();
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs());
-      });
-    });
-
-    group("expecting one call", () {
-      test("zero actual calls fails", () {
-        expectFail(
-            "No matching calls (actually, no calls at all).\n"
-            "$noMatchingCallsFooter", () {
-          verify(mock.methodWithoutArgs()).called(1);
-        });
-      });
-
-      test("one actual call passes", () {
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs()).called(1);
-      });
-
-      test("more than one actual call fails", () {
-        mock.methodWithoutArgs();
-        mock.methodWithoutArgs();
-        expectFail("Expected: <1>\n  Actual: <2>\nUnexpected number of calls\n",
-            () {
-          verify(mock.methodWithoutArgs()).called(1);
-        });
-      });
-    });
-
-    group("expecting more than two calls", () {
-      test("zero actual calls fails", () {
-        expectFail(
-            "No matching calls (actually, no calls at all).\n"
-            "$noMatchingCallsFooter", () {
-          verify(mock.methodWithoutArgs()).called(greaterThan(2));
-        });
-      });
-
-      test("one actual call fails", () {
-        mock.methodWithoutArgs();
-        expectFail(
-            "Expected: a value greater than <2>\n"
-            "  Actual: <1>\n"
-            "   Which: is not a value greater than <2>\n"
-            "Unexpected number of calls\n", () {
-          verify(mock.methodWithoutArgs()).called(greaterThan(2));
-        });
-      });
-
-      test("three actual calls passes", () {
-        mock.methodWithoutArgs();
-        mock.methodWithoutArgs();
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs()).called(greaterThan(2));
-      });
-    });
-
-    group("expecting zero calls", () {
-      test("zero actual calls passes", () {
-        expectFail(
-            "No matching calls (actually, no calls at all).\n"
-            "$noMatchingCallsFooter", () {
-          verify(mock.methodWithoutArgs()).called(0);
-        });
-      });
-
-      test("one actual call fails", () {
-        mock.methodWithoutArgs();
-        expectFail(
-            "Expected: <0>\n"
-            "  Actual: <1>\n"
-            "Unexpected number of calls\n", () {
-          verify(mock.methodWithoutArgs()).called(0);
-        });
-      });
-    });
-
-    group("verifyNever", () {
-      test("zero passes", () {
-        verifyNever(mock.methodWithoutArgs());
-      });
-
-      test("one fails", () {
-        mock.methodWithoutArgs();
-        expectFail(
-            "Unexpected calls. All calls: MockedClass.methodWithoutArgs()", () {
-          verifyNever(mock.methodWithoutArgs());
-        });
-      });
-    });
-
-    group("doesn't count already verified again", () {
-      test("fail case", () {
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs());
-        expectFail(
-            "No matching calls. All calls: [VERIFIED] MockedClass.methodWithoutArgs()\n"
-            "$noMatchingCallsFooter", () {
-          verify(mock.methodWithoutArgs());
-        });
-      });
-
-      test("pass case", () {
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs());
-        mock.methodWithoutArgs();
-        verify(mock.methodWithoutArgs());
-      });
-    });
-  });
-
-  group("verifyZeroInteractions()", () {
-    test("never touched pass", () {
-      verifyZeroInteractions(mock);
-    });
-
-    test("any touch fails", () {
-      mock.methodWithoutArgs();
-      expectFail(
-          "No interaction expected, but following found: MockedClass.methodWithoutArgs()",
-          () {
-        verifyZeroInteractions(mock);
-      });
-    });
-
-    test("verifired call fails", () {
-      mock.methodWithoutArgs();
-      verify(mock.methodWithoutArgs());
-      expectFail(
-          "No interaction expected, but following found: [VERIFIED] MockedClass.methodWithoutArgs()",
-          () {
-        verifyZeroInteractions(mock);
-      });
-    });
-  });
-
-  group("verifyNoMoreInteractions()", () {
-    test("never touched pass", () {
-      verifyNoMoreInteractions(mock);
-    });
-
-    test("any unverified touch fails", () {
-      mock.methodWithoutArgs();
-      expectFail(
-          "No more calls expected, but following found: MockedClass.methodWithoutArgs()",
-          () {
-        verifyNoMoreInteractions(mock);
-      });
-    });
-
-    test("verified touch passes", () {
-      mock.methodWithoutArgs();
-      verify(mock.methodWithoutArgs());
-      verifyNoMoreInteractions(mock);
-    });
-
-    test("throws if given a real object", () {
-      expect(
-          () => verifyNoMoreInteractions(new RealClass()), throwsArgumentError);
-    });
-  });
-
-  group("verifyInOrder()", () {
-    test("right order passes", () {
-      mock.methodWithoutArgs();
-      mock.getter;
-      verifyInOrder([mock.methodWithoutArgs(), mock.getter]);
-    });
-
-    test("wrong order fails", () {
-      mock.methodWithoutArgs();
-      mock.getter;
-      expectFail(
-          "Matching call #1 not found. All calls: MockedClass.methodWithoutArgs(), MockedClass.getter",
-          () {
-        verifyInOrder([mock.getter, mock.methodWithoutArgs()]);
-      });
-    });
-
-    test("uncomplete fails", () {
-      mock.methodWithoutArgs();
-      expectFail(
-          "Matching call #1 not found. All calls: MockedClass.methodWithoutArgs()",
-          () {
-        verifyInOrder([mock.methodWithoutArgs(), mock.getter]);
-      });
-    });
-
-    test("methods can be called again and again", () {
-      mock.methodWithoutArgs();
-      mock.getter;
-      mock.methodWithoutArgs();
-      verifyInOrder(
-          [mock.methodWithoutArgs(), mock.getter, mock.methodWithoutArgs()]);
-    });
-
-    test("methods can be called again and again - fail case", () {
-      mock.methodWithoutArgs();
-      mock.methodWithoutArgs();
-      mock.getter;
-      expectFail(
-          "Matching call #2 not found. All calls: MockedClass.methodWithoutArgs(), MockedClass.methodWithoutArgs(), MockedClass.getter",
-          () {
-        verifyInOrder(
-            [mock.methodWithoutArgs(), mock.getter, mock.methodWithoutArgs()]);
-      });
-    });
-  });
-
-  group("capture", () {
-    test("capture should work as captureOut", () {
-      mock.methodWithNormalArgs(42);
-      expect(
-          verify(mock.methodWithNormalArgs(typed(captureAny))).captured.single,
-          equals(42));
-    });
-
-    test("should captureOut list arguments", () {
-      mock.methodWithListArgs([42]);
-      expect(verify(mock.methodWithListArgs(typed(captureAny))).captured.single,
-          equals([42]));
-    });
-
-    test("should captureOut multiple arguments", () {
-      mock.methodWithPositionalArgs(1, 2);
-      expect(
-          verify(mock.methodWithPositionalArgs(
-                  typed(captureAny), typed(captureAny)))
-              .captured,
-          equals([1, 2]));
-    });
-
-    test("should captureOut with matching arguments", () {
-      mock.methodWithPositionalArgs(1);
-      mock.methodWithPositionalArgs(2, 3);
-      expect(
-          verify(mock.methodWithPositionalArgs(
-                  typed(captureAny), typed(captureAny)))
-              .captured,
-          equals([2, 3]));
-    });
-
-    test("should captureOut multiple invocations", () {
-      mock.methodWithNormalArgs(1);
-      mock.methodWithNormalArgs(2);
-      expect(verify(mock.methodWithNormalArgs(typed(captureAny))).captured,
-          equals([1, 2]));
-    });
-  });
-
   group("throwOnMissingStub", () {
     test("should throw when a mock was called without a matching stub", () {
       throwOnMissingStub(mock);
diff --git a/test/until_called_test.dart b/test/until_called_test.dart
new file mode 100644
index 0000000..e4c17e3
--- /dev/null
+++ b/test/until_called_test.dart
@@ -0,0 +1,306 @@
+// Copyright 2016 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.
+
+import 'dart:async';
+
+import 'package:mockito/mockito.dart';
+import 'package:mockito/src/mock.dart' show resetMockitoState;
+import 'package:test/test.dart';
+
+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';
+  String typeParameterizedFn(List<int> w, List<int> x,
+          [List<int> y, List<int> z]) =>
+      'Real';
+  String typeParameterizedNamedFn(List<int> w, List<int> x,
+          {List<int> y, List<int> z}) =>
+      'Real';
+  String get getter => 'Real';
+  set setter(String arg) {
+    throw new StateError('I must be mocked');
+  }
+}
+
+class CallMethodsEvent {}
+
+/// Listens on a stream and upon any event calls all methods in [RealClass].
+class RealClassController {
+  final RealClass _realClass;
+
+  RealClassController(
+      this._realClass, StreamController<CallMethodsEvent> streamController) {
+    streamController.stream.listen(_callAllMethods);
+  }
+
+  Future<Null> _callAllMethods(_) async {
+    _realClass
+      ..methodWithoutArgs()
+      ..methodWithNormalArgs(1)
+      ..methodWithListArgs([1, 2])
+      ..methodWithPositionalArgs(1, 2)
+      ..methodWithNamedArgs(1, y: 2)
+      ..methodWithTwoNamedArgs(1, y: 2, z: 3)
+      ..methodWithObjArgs(new RealClass())
+      ..typeParameterizedFn([1, 2], [3, 4], [5, 6], [7, 8])
+      ..typeParameterizedNamedFn([1, 2], [3, 4], y: [5, 6], z: [7, 8])
+      ..getter
+      ..setter = 'A';
+  }
+}
+
+class MockedClass extends Mock implements RealClass {}
+
+void main() {
+  MockedClass mock;
+
+  setUp(() {
+    mock = new MockedClass();
+  });
+
+  tearDown(() {
+    // In some of the tests that expect an Error to be thrown, Mockito's
+    // global state can become invalid. Reset it.
+    resetMockitoState();
+  });
+
+  group('untilCalled', () {
+    StreamController<CallMethodsEvent> streamController =
+        new StreamController.broadcast();
+
+    group('on methods already called', () {
+      test('waits for method without args', () async {
+        mock.methodWithoutArgs();
+
+        await untilCalled(mock.methodWithoutArgs());
+
+        verify(mock.methodWithoutArgs()).called(1);
+      });
+
+      test('waits for method with normal args', () async {
+        mock.methodWithNormalArgs(1);
+
+        await untilCalled(mock.methodWithNormalArgs(typed(any)));
+
+        verify(mock.methodWithNormalArgs(typed(any))).called(1);
+      });
+
+      test('waits for method with list args', () async {
+        mock.methodWithListArgs([1]);
+
+        await untilCalled(mock.methodWithListArgs(typed(any)));
+
+        verify(mock.methodWithListArgs(typed(any))).called(1);
+      });
+
+      test('waits for method with positional args', () async {
+        mock.methodWithPositionalArgs(1, 2);
+
+        await untilCalled(
+            mock.methodWithPositionalArgs(typed(any), typed(any)));
+
+        verify(mock.methodWithPositionalArgs(typed(any), typed(any))).called(1);
+      });
+
+      test('waits for method with named args', () async {
+        mock.methodWithNamedArgs(1, y: 2);
+
+        await untilCalled(mock.methodWithNamedArgs(any, y: anyNamed('y')));
+
+        verify(mock.methodWithNamedArgs(any, y: anyNamed('y'))).called(1);
+      });
+
+      test('waits for method with two named args', () async {
+        mock.methodWithTwoNamedArgs(1, y: 2, z: 3);
+
+        await untilCalled(mock.methodWithTwoNamedArgs(any,
+            y: anyNamed('y'), z: anyNamed('z')));
+
+        verify(mock.methodWithTwoNamedArgs(any,
+                y: anyNamed('y'), z: anyNamed('z')))
+            .called(1);
+      });
+
+      test('waits for method with obj args', () async {
+        mock.methodWithObjArgs(new RealClass());
+
+        await untilCalled(mock.methodWithObjArgs(typed(any)));
+
+        verify(mock.methodWithObjArgs(typed(any))).called(1);
+      });
+
+      test('waits for function with positional parameters', () async {
+        mock.typeParameterizedFn([1, 2], [3, 4], [5, 6], [7, 8]);
+
+        await untilCalled(mock.typeParameterizedFn(
+            typed(any), typed(any), typed(any), typed(any)));
+
+        verify(mock.typeParameterizedFn(
+                typed(any), typed(any), typed(any), typed(any)))
+            .called(1);
+      });
+
+      test('waits for function with named parameters', () async {
+        mock.typeParameterizedNamedFn([1, 2], [3, 4], y: [5, 6], z: [7, 8]);
+
+        await untilCalled(mock.typeParameterizedNamedFn(any, any,
+            y: anyNamed('y'), z: anyNamed('z')));
+
+        verify(mock.typeParameterizedNamedFn(any, any,
+                y: anyNamed('y'), z: anyNamed('z')))
+            .called(1);
+      });
+
+      test('waits for getter', () async {
+        mock.getter;
+
+        await untilCalled(mock.getter);
+
+        verify(mock.getter).called(1);
+      });
+
+      test('waits for setter', () async {
+        mock.setter = 'A';
+
+        await untilCalled(mock.setter = 'A');
+
+        verify(mock.setter = 'A').called(1);
+      });
+    });
+
+    group('on methods not yet called', () {
+      setUp(() {
+        new RealClassController(mock, streamController);
+      });
+
+      test('waits for method without args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithoutArgs());
+
+        await untilCalled(mock.methodWithoutArgs());
+
+        verify(mock.methodWithoutArgs()).called(1);
+      });
+
+      test('waits for method with normal args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithNormalArgs(typed(any)));
+
+        await untilCalled(mock.methodWithNormalArgs(typed(any)));
+
+        verify(mock.methodWithNormalArgs(typed(any))).called(1);
+      });
+
+      test('waits for method with list args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithListArgs(typed(any)));
+
+        await untilCalled(mock.methodWithListArgs(typed(any)));
+
+        verify(mock.methodWithListArgs(typed(any))).called(1);
+      });
+
+      test('waits for method with positional args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithPositionalArgs(typed(any), typed(any)));
+
+        await untilCalled(
+            mock.methodWithPositionalArgs(typed(any), typed(any)));
+
+        verify(mock.methodWithPositionalArgs(typed(any), typed(any))).called(1);
+      });
+
+      test('waits for method with named args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithNamedArgs(any, y: anyNamed('y')));
+
+        await untilCalled(mock.methodWithNamedArgs(any, y: anyNamed('y')));
+
+        verify(mock.methodWithNamedArgs(any, y: anyNamed('y'))).called(1);
+      });
+
+      test('waits for method with two named args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithTwoNamedArgs(any,
+            y: anyNamed('y'), z: anyNamed('z')));
+
+        await untilCalled(mock.methodWithTwoNamedArgs(any,
+            y: anyNamed('y'), z: anyNamed('z')));
+
+        verify(mock.methodWithTwoNamedArgs(any,
+                y: anyNamed('y'), z: anyNamed('z')))
+            .called(1);
+      });
+
+      test('waits for method with obj args', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.methodWithObjArgs(typed(any)));
+
+        await untilCalled(mock.methodWithObjArgs(typed(any)));
+
+        verify(mock.methodWithObjArgs(typed(any))).called(1);
+      });
+
+      test('waits for function with positional parameters', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.typeParameterizedFn(
+            typed(any), typed(any), typed(any), typed(any)));
+
+        await untilCalled(mock.typeParameterizedFn(
+            typed(any), typed(any), typed(any), typed(any)));
+
+        verify(mock.typeParameterizedFn(
+                typed(any), typed(any), typed(any), typed(any)))
+            .called(1);
+      });
+
+      test('waits for function with named parameters', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.typeParameterizedNamedFn(any, any,
+            y: anyNamed('y'), z: anyNamed('z')));
+
+        await untilCalled(mock.typeParameterizedNamedFn(any, any,
+            y: anyNamed('y'), z: anyNamed('z')));
+
+        verify(mock.typeParameterizedNamedFn(any, any,
+                y: anyNamed('y'), z: anyNamed('z')))
+            .called(1);
+      });
+
+      test('waits for getter', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.getter);
+
+        await untilCalled(mock.getter);
+
+        verify(mock.getter).called(1);
+      });
+
+      test('waits for setter', () async {
+        streamController.add(new CallMethodsEvent());
+        verifyNever(mock.setter = 'A');
+
+        await untilCalled(mock.setter = 'A');
+
+        verify(mock.setter = 'A').called(1);
+      });
+    });
+  });
+}
diff --git a/test/verify_test.dart b/test/verify_test.dart
new file mode 100644
index 0000000..27d77ed
--- /dev/null
+++ b/test/verify_test.dart
@@ -0,0 +1,437 @@
+// Copyright 2018 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.
+
+import 'package:mockito/mockito.dart';
+import 'package:mockito/src/mock.dart' show resetMockitoState;
+import 'package:test/test.dart';
+
+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 methodWithObjArgs(RealClass x) => 'Real';
+  String get getter => 'Real';
+  set setter(String arg) {
+    throw new StateError('I must be mocked');
+  }
+}
+
+class MockedClass extends Mock implements RealClass {}
+
+expectFail(String expectedMessage, expectedToFail()) {
+  try {
+    expectedToFail();
+    fail('It was expected to fail!');
+  } catch (e) {
+    if (!(e is TestFailure)) {
+      throw e;
+    } else {
+      if (expectedMessage != e.message) {
+        throw new TestFailure('Failed, but with wrong message: ${e.message}');
+      }
+    }
+  }
+}
+
+String noMatchingCallsFooter = '(If you called `verify(...).called(0);`, '
+    'please instead use `verifyNever(...);`.)';
+
+void main() {
+  MockedClass mock;
+
+  setUp(() {
+    mock = new MockedClass();
+  });
+
+  tearDown(() {
+    // In some of the tests that expect an Error to be thrown, Mockito's
+    // global state can become invalid. Reset it.
+    resetMockitoState();
+  });
+
+  group('verify', () {
+    test('should verify method without args', () {
+      mock.methodWithoutArgs();
+      verify(mock.methodWithoutArgs());
+    });
+
+    test('should verify method with normal args', () {
+      mock.methodWithNormalArgs(42);
+      expectFail(
+          'No matching calls. All calls: MockedClass.methodWithNormalArgs(42)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithNormalArgs(43));
+      });
+      verify(mock.methodWithNormalArgs(42));
+    });
+
+    test('should mock method with positional args', () {
+      mock.methodWithPositionalArgs(42, 17);
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithPositionalArgs(42, 17)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithPositionalArgs(42));
+      });
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithPositionalArgs(42, 17)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithPositionalArgs(42, 18));
+      });
+      verify(mock.methodWithPositionalArgs(42, 17));
+    });
+
+    test('should mock method with named args', () {
+      mock.methodWithNamedArgs(42, y: 17);
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithNamedArgs(42, {y: 17})\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithNamedArgs(42));
+      });
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithNamedArgs(42, {y: 17})\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithNamedArgs(42, y: 18));
+      });
+      verify(mock.methodWithNamedArgs(42, y: 17));
+    });
+
+    test('should mock method with mock args', () {
+      var m1 = named(new MockedClass(), name: 'm1');
+      mock.methodWithObjArgs(m1);
+      expectFail(
+          'No matching calls. All calls: MockedClass.methodWithObjArgs(m1)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithObjArgs(new MockedClass()));
+      });
+      verify(mock.methodWithObjArgs(m1));
+    });
+
+    test('should mock method with list args', () {
+      mock.methodWithListArgs([42]);
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithListArgs([42])\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithListArgs([43]));
+      });
+      verify(mock.methodWithListArgs([42]));
+    });
+
+    test('should mock method with argument matcher', () {
+      mock.methodWithNormalArgs(100);
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithNormalArgs(100)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithNormalArgs(typed(argThat(greaterThan(100)))));
+      });
+      verify(
+          mock.methodWithNormalArgs(typed(argThat(greaterThanOrEqualTo(100)))));
+    });
+
+    test('should mock method with mix of argument matchers and real things',
+        () {
+      mock.methodWithPositionalArgs(100, 17);
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithPositionalArgs(100, 17)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithPositionalArgs(
+            typed(argThat(greaterThanOrEqualTo(100))), 18));
+      });
+      expectFail(
+          'No matching calls. All calls: '
+          'MockedClass.methodWithPositionalArgs(100, 17)\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.methodWithPositionalArgs(
+            typed(argThat(greaterThan(100))), 17));
+      });
+      verify(mock.methodWithPositionalArgs(
+          typed(argThat(greaterThanOrEqualTo(100))), 17));
+    });
+
+    test('should mock getter', () {
+      mock.getter;
+      verify(mock.getter);
+    });
+
+    test('should mock setter', () {
+      mock.setter = 'A';
+      expectFail(
+          'No matching calls. All calls: MockedClass.setter==A\n'
+          '$noMatchingCallsFooter', () {
+        verify(mock.setter = 'B');
+      });
+      verify(mock.setter = 'A');
+    });
+
+    test('should throw meaningful errors when verification is interrupted', () {
+      var badHelper = () => throw 'boo';
+      try {
+        verify(mock.methodWithNamedArgs(42, y: badHelper()));
+        fail('verify call was expected to throw!');
+      } catch (_) {}
+      // At this point, verification was interrupted, so
+      // `_verificationInProgress` is still `true`. Calling mock methods below
+      // adds items to `_verifyCalls`.
+      mock.methodWithNamedArgs(42, y: 17);
+      mock.methodWithNamedArgs(42, y: 17);
+      try {
+        verify(mock.methodWithNamedArgs(42, y: 17));
+        fail('verify call was expected to throw!');
+      } catch (e) {
+        expect(e, new isInstanceOf<StateError>());
+        expect(
+            e.message,
+            contains('Verification appears to be in progress. '
+                '2 verify calls have been stored.'));
+      }
+    });
+  });
+
+  group('verify qualifies', () {
+    group('unqualified as at least one', () {
+      test('zero fails', () {
+        expectFail(
+            'No matching calls (actually, no calls at all).\n'
+            '$noMatchingCallsFooter', () {
+          verify(mock.methodWithoutArgs());
+        });
+      });
+
+      test('one passes', () {
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs());
+      });
+
+      test('more than one passes', () {
+        mock.methodWithoutArgs();
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs());
+      });
+    });
+
+    group('expecting one call', () {
+      test('zero actual calls fails', () {
+        expectFail(
+            'No matching calls (actually, no calls at all).\n'
+            '$noMatchingCallsFooter', () {
+          verify(mock.methodWithoutArgs()).called(1);
+        });
+      });
+
+      test('one actual call passes', () {
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs()).called(1);
+      });
+
+      test('more than one actual call fails', () {
+        mock.methodWithoutArgs();
+        mock.methodWithoutArgs();
+        expectFail('Expected: <1>\n  Actual: <2>\nUnexpected number of calls\n',
+            () {
+          verify(mock.methodWithoutArgs()).called(1);
+        });
+      });
+    });
+
+    group('expecting more than two calls', () {
+      test('zero actual calls fails', () {
+        expectFail(
+            'No matching calls (actually, no calls at all).\n'
+            '$noMatchingCallsFooter', () {
+          verify(mock.methodWithoutArgs()).called(greaterThan(2));
+        });
+      });
+
+      test('one actual call fails', () {
+        mock.methodWithoutArgs();
+        expectFail(
+            'Expected: a value greater than <2>\n'
+            '  Actual: <1>\n'
+            '   Which: is not a value greater than <2>\n'
+            'Unexpected number of calls\n', () {
+          verify(mock.methodWithoutArgs()).called(greaterThan(2));
+        });
+      });
+
+      test('three actual calls passes', () {
+        mock.methodWithoutArgs();
+        mock.methodWithoutArgs();
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs()).called(greaterThan(2));
+      });
+    });
+
+    group('expecting zero calls', () {
+      test('zero actual calls passes', () {
+        expectFail(
+            'No matching calls (actually, no calls at all).\n'
+            '$noMatchingCallsFooter', () {
+          verify(mock.methodWithoutArgs()).called(0);
+        });
+      });
+
+      test('one actual call fails', () {
+        mock.methodWithoutArgs();
+        expectFail(
+            'Expected: <0>\n'
+            '  Actual: <1>\n'
+            'Unexpected number of calls\n', () {
+          verify(mock.methodWithoutArgs()).called(0);
+        });
+      });
+    });
+
+    group('verifyNever', () {
+      test('zero passes', () {
+        verifyNever(mock.methodWithoutArgs());
+      });
+
+      test('one fails', () {
+        mock.methodWithoutArgs();
+        expectFail(
+            'Unexpected calls. All calls: MockedClass.methodWithoutArgs()', () {
+          verifyNever(mock.methodWithoutArgs());
+        });
+      });
+    });
+
+    group('does not count already verified again', () {
+      test('fail case', () {
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs());
+        expectFail(
+            'No matching calls. '
+            'All calls: [VERIFIED] MockedClass.methodWithoutArgs()\n'
+            '$noMatchingCallsFooter', () {
+          verify(mock.methodWithoutArgs());
+        });
+      });
+
+      test('pass case', () {
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs());
+        mock.methodWithoutArgs();
+        verify(mock.methodWithoutArgs());
+      });
+    });
+  });
+
+  group('verifyZeroInteractions', () {
+    test('never touched pass', () {
+      verifyZeroInteractions(mock);
+    });
+
+    test('any touch fails', () {
+      mock.methodWithoutArgs();
+      expectFail(
+          'No interaction expected, but following found: '
+          'MockedClass.methodWithoutArgs()', () {
+        verifyZeroInteractions(mock);
+      });
+    });
+
+    test('verified call fails', () {
+      mock.methodWithoutArgs();
+      verify(mock.methodWithoutArgs());
+      expectFail(
+          'No interaction expected, but following found: '
+          '[VERIFIED] MockedClass.methodWithoutArgs()', () {
+        verifyZeroInteractions(mock);
+      });
+    });
+  });
+
+  group('verifyNoMoreInteractions', () {
+    test('never touched pass', () {
+      verifyNoMoreInteractions(mock);
+    });
+
+    test('any unverified touch fails', () {
+      mock.methodWithoutArgs();
+      expectFail(
+          'No more calls expected, but following found: '
+          'MockedClass.methodWithoutArgs()', () {
+        verifyNoMoreInteractions(mock);
+      });
+    });
+
+    test('verified touch passes', () {
+      mock.methodWithoutArgs();
+      verify(mock.methodWithoutArgs());
+      verifyNoMoreInteractions(mock);
+    });
+
+    test('throws if given a real object', () {
+      expect(
+          () => verifyNoMoreInteractions(new RealClass()), throwsArgumentError);
+    });
+  });
+
+  group('verifyInOrder', () {
+    test('right order passes', () {
+      mock.methodWithoutArgs();
+      mock.getter;
+      verifyInOrder([mock.methodWithoutArgs(), mock.getter]);
+    });
+
+    test('wrong order fails', () {
+      mock.methodWithoutArgs();
+      mock.getter;
+      expectFail(
+          'Matching call #1 not found. All calls: '
+          'MockedClass.methodWithoutArgs(), MockedClass.getter', () {
+        verifyInOrder([mock.getter, mock.methodWithoutArgs()]);
+      });
+    });
+
+    test('incomplete fails', () {
+      mock.methodWithoutArgs();
+      expectFail(
+          'Matching call #1 not found. All calls: '
+          'MockedClass.methodWithoutArgs()', () {
+        verifyInOrder([mock.methodWithoutArgs(), mock.getter]);
+      });
+    });
+
+    test('methods can be called again and again', () {
+      mock.methodWithoutArgs();
+      mock.getter;
+      mock.methodWithoutArgs();
+      verifyInOrder(
+          [mock.methodWithoutArgs(), mock.getter, mock.methodWithoutArgs()]);
+    });
+
+    test('methods can be called again and again - fail case', () {
+      mock.methodWithoutArgs();
+      mock.methodWithoutArgs();
+      mock.getter;
+      expectFail(
+          'Matching call #2 not found. All calls: '
+          'MockedClass.methodWithoutArgs(), MockedClass.methodWithoutArgs(), '
+          'MockedClass.getter', () {
+        verifyInOrder(
+            [mock.methodWithoutArgs(), mock.getter, mock.methodWithoutArgs()]);
+      });
+    });
+  });
+}