diff --git a/lib/src/invocation_matcher.dart b/lib/src/invocation_matcher.dart
new file mode 100644
index 0000000..c176a1b
--- /dev/null
+++ b/lib/src/invocation_matcher.dart
@@ -0,0 +1,167 @@
+import 'package:collection/collection.dart';
+import 'package:matcher/matcher.dart';
+import 'package:meta/meta.dart';
+
+/// Returns a matcher that expects an invocation that matches arguments given.
+///
+/// Both [positionalArguments] and [namedArguments] can also be [Matcher]s:
+///     // Expects an invocation of "foo(String a, bool b)" where "a" must be
+///     // the value 'hello' but "b" may be any value. This would match both
+///     // foo('hello', true), foo('hello', false), and foo('hello', null).
+///     expect(fooInvocation, invokes(
+///       #foo,
+///       positionalArguments: ['hello', any]
+///     ));
+///
+/// Suitable for use in mocking libraries, where `noSuchMethod` can be used to
+/// get a handle to attempted [Invocation] objects and then compared against
+/// what a user expects to be called.
+Matcher invokes(
+  Symbol memberName, {
+  List positionalArguments: const [],
+  Map<Symbol, dynamic> namedArguments: const {},
+  bool isGetter: false,
+  bool isSetter: false,
+}) {
+  if (isGetter && isSetter) {
+    throw new ArgumentError('Cannot set isGetter and iSetter');
+  }
+  if (positionalArguments == null) {
+    throw new ArgumentError.notNull('positionalArguments');
+  }
+  if (namedArguments == null) {
+    throw new ArgumentError.notNull('namedArguments');
+  }
+  return new _InvocationMatcher(new _InvocationSignature(
+    memberName: memberName,
+    positionalArguments: positionalArguments,
+    namedArguments: namedArguments,
+    isGetter: isGetter,
+    isSetter: isSetter,
+  ));
+}
+
+/// Returns a matcher that matches the name and arguments of an [invocation].
+///
+/// To expect the same _signature_ see [invokes].
+Matcher isInvocation(Invocation invocation) =>
+    new _InvocationMatcher(invocation);
+
+class _InvocationSignature extends Invocation {
+  @override
+  final Symbol memberName;
+
+  @override
+  final List positionalArguments;
+
+  @override
+  final Map<Symbol, dynamic> namedArguments;
+
+  @override
+  final bool isGetter;
+
+  @override
+  final bool isSetter;
+
+  _InvocationSignature({
+    @required this.memberName,
+    this.positionalArguments: const [],
+    this.namedArguments: const {},
+    this.isGetter: false,
+    this.isSetter: false,
+  });
+
+  @override
+  bool get isMethod => !isAccessor;
+}
+
+class _InvocationMatcher implements Matcher {
+  static Description _describeInvocation(Description d, Invocation invocation) {
+    // For a getter or a setter, just return get <member> or set <member> <arg>.
+    if (invocation.isAccessor) {
+      d = d
+          .add(invocation.isGetter ? 'get ' : 'set ')
+          .add(_symbolToString(invocation.memberName));
+      if (invocation.isSetter) {
+        d = d.add(' ').addDescriptionOf(invocation.positionalArguments.first);
+      }
+      return d;
+    }
+    // For a method, return <member>(<args>).
+    d = d
+        .add(_symbolToString(invocation.memberName))
+        .add('(')
+        .addAll('', ', ', '', invocation.positionalArguments);
+    if (invocation.positionalArguments.isNotEmpty &&
+        invocation.namedArguments.isNotEmpty) {
+      d = d.add(', ');
+    }
+    // Also added named arguments, if any.
+    return d.addAll('', ', ', '', _namedArgsAndValues(invocation)).add(')');
+  }
+
+  // Returns named arguments as an iterable of '<name>: <value>'.
+  static Iterable<String> _namedArgsAndValues(Invocation invocation) =>
+      invocation.namedArguments.keys.map/*<String>*/((name) =>
+          '${_symbolToString(name)}: ${invocation.namedArguments[name]}');
+
+  // This will give is a mangled symbol in dart2js/aot with minification
+  // enabled, but it's safe to assume very few people will use the invocation
+  // matcher in a production test anyway due to noSuchMethod.
+  static String _symbolToString(Symbol symbol) {
+    return symbol.toString().split('"')[1];
+  }
+
+  final Invocation _invocation;
+
+  _InvocationMatcher(this._invocation) {
+    if (_invocation == null) {
+      throw new ArgumentError.notNull();
+    }
+  }
+
+  @override
+  Description describe(Description d) => _describeInvocation(d, _invocation);
+
+  // TODO(matanl): Better implement describeMismatch and use state from matches.
+  // Specifically, if a Matcher is passed as an argument, we'd like to get an
+  // error like "Expected fly(miles: > 10), Actual: fly(miles: 5)".
+  @override
+  Description describeMismatch(item, Description d, _, __) {
+    if (item is Invocation) {
+      d = d.add('Does not match ');
+      return _describeInvocation(d, item);
+    }
+    return d.add('Is not an Invocation');
+  }
+
+  @override
+  bool matches(item, _) =>
+      item is Invocation &&
+      _invocation.memberName == item.memberName &&
+      _invocation.isSetter == item.isSetter &&
+      _invocation.isGetter == item.isGetter &&
+      const ListEquality(const _MatcherEquality())
+          .equals(_invocation.positionalArguments, item.positionalArguments) &&
+      const MapEquality(values: const _MatcherEquality())
+          .equals(_invocation.namedArguments, item.namedArguments);
+}
+
+class _MatcherEquality extends DefaultEquality /* <Matcher | E> */ {
+  const _MatcherEquality();
+
+  @override
+  bool equals(e1, e2) {
+    if (e1 is Matcher && e2 is! Matcher) {
+      return e1.matches(e2, const {});
+    }
+    if (e2 is Matcher && e1 is! Matcher) {
+      return e2.matches(e1, const {});
+    }
+    return super.equals(e1, e2);
+  }
+
+  // We force collisions on every value so equals() is called.
+  @override
+  int hash(_) => 0;
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index 07298d5..cd508e3 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: mockito
-version: 1.0.1+1
+version: 1.0.1+2
 authors:
   - Dmitriy Fibulwinter <fibulwinter@gmail.com>
   - Ted Sander <tsander@google.com>
@@ -10,5 +10,6 @@
 environment:
   sdk: '>=1.0.0 <2.0.0'
 dependencies:
-  meta: '>=1.0.4 <2.0.0'
+  matcher: '^0.12.0'
+  meta: '^1.0.4'
   test: '>=0.12.0 <0.13.0'
diff --git a/test/invocation_matcher_test.dart b/test/invocation_matcher_test.dart
new file mode 100644
index 0000000..d148196
--- /dev/null
+++ b/test/invocation_matcher_test.dart
@@ -0,0 +1,158 @@
+import 'package:mockito/src/invocation_matcher.dart';
+import 'package:test/test.dart';
+
+Invocation lastInvocation;
+
+void main() {
+  const stub = const Stub();
+
+  group('$isInvocation', () {
+    test('positional arguments', () {
+      var call1 = stub.say('Hello');
+      var call2 = stub.say('Hello');
+      var call3 = stub.say('Guten Tag');
+      shouldPass(call1, isInvocation(call2));
+      shouldFail(
+        call1,
+        isInvocation(call3),
+        "Expected: say('Guten Tag') "
+            "Actual: <Instance of '${call3.runtimeType}'> "
+            "Which: Does not match say('Hello')",
+      );
+    });
+
+    test('named arguments', () {
+      var call1 = stub.eat('Chicken', alsoDrink: true);
+      var call2 = stub.eat('Chicken', alsoDrink: true);
+      var call3 = stub.eat('Chicken', alsoDrink: false);
+      shouldPass(call1, isInvocation(call2));
+      shouldFail(
+        call1,
+        isInvocation(call3),
+        "Expected: eat('Chicken', 'alsoDrink: false') "
+            "Actual: <Instance of '${call3.runtimeType}'> "
+            "Which: Does not match eat('Chicken', 'alsoDrink: true')",
+      );
+    });
+
+    test('optional arguments', () {
+      var call1 = stub.lie(true);
+      var call2 = stub.lie(true);
+      var call3 = stub.lie(false);
+      shouldPass(call1, isInvocation(call2));
+      shouldFail(
+        call1,
+        isInvocation(call3),
+        "Expected: lie(<false>) "
+            "Actual: <Instance of '${call3.runtimeType}'> "
+            "Which: Does not match lie(<true>)",
+      );
+    });
+
+    test('getter', () {
+      var call1 = stub.value;
+      var call2 = stub.value;
+      stub.value = true;
+      var call3 = Stub.lastInvocation;
+      shouldPass(call1, isInvocation(call2));
+      shouldFail(
+        call1,
+        isInvocation(call3),
+        "Expected: set value= <true> "
+            "Actual: <Instance of '${call3.runtimeType}'> "
+            "Which: Does not match get value",
+      );
+    });
+
+    test('setter', () {
+      stub.value = true;
+      var call1 = Stub.lastInvocation;
+      stub.value = true;
+      var call2 = Stub.lastInvocation;
+      stub.value = false;
+      var call3 = Stub.lastInvocation;
+      shouldPass(call1, isInvocation(call2));
+      shouldFail(
+        call1,
+        isInvocation(call3),
+        "Expected: set value= <false> "
+            "Actual: <Instance of '${call3.runtimeType}'> "
+            "Which: Does not match set value= <true>",
+      );
+    });
+  });
+
+  group('$invokes', () {
+    test('positional arguments', () {
+      var call = stub.say('Hello');
+      shouldPass(call, invokes(#say, positionalArguments: ['Hello']));
+      shouldPass(call, invokes(#say, positionalArguments: [anything]));
+      shouldFail(
+        call,
+        invokes(#say, positionalArguments: [isNull]),
+        "Expected: say(null) "
+            "Actual: <Instance of '${call.runtimeType}'> "
+            "Which: Does not match say('Hello')",
+      );
+    });
+
+    test('named arguments', () {
+      var call = stub.fly(miles: 10);
+      shouldPass(call, invokes(#fly, namedArguments: {#miles: 10}));
+      shouldPass(call, invokes(#fly, namedArguments: {#miles: greaterThan(5)}));
+      shouldFail(
+        call,
+        invokes(#fly, namedArguments: {#miles: 11}),
+        "Expected: fly('miles: 11') "
+            "Actual: <Instance of '${call.runtimeType}'> "
+            "Which: Does not match fly('miles: 10')",
+      );
+    });
+  });
+}
+
+abstract class Interface {
+  bool get value;
+  set value(value);
+  say(String text);
+  eat(String food, {bool alsoDrink});
+  lie([bool facingDown]);
+  fly({int miles});
+}
+
+/// An example of a class that captures Invocation objects.
+///
+/// Any call always returns an [Invocation].
+class Stub implements Interface {
+  static Invocation lastInvocation;
+
+  const Stub();
+
+  @override
+  noSuchMethod(Invocation invocation) => lastInvocation = invocation;
+}
+
+// Copied from package:test, which doesn't expose it to users.
+// https://github.com/dart-lang/matcher/issues/39
+void shouldFail(value, Matcher matcher, expected) {
+  var failed = false;
+  try {
+    expect(value, matcher);
+  } on TestFailure catch (err) {
+    failed = true;
+
+    var _errorString = err.message;
+
+    if (expected is String) {
+      expect(_errorString, equalsIgnoringWhitespace(expected));
+    } else {
+      expect(_errorString.replaceAll('\n', ''), expected);
+    }
+  }
+
+  expect(failed, isTrue, reason: 'Expected to fail.');
+}
+
+void shouldPass(value, Matcher matcher) {
+  expect(value, matcher);
+}
diff --git a/test/mockito_test.dart b/test/mockito_test.dart
index 2e07913..2dd4b9b 100644
--- a/test/mockito_test.dart
+++ b/test/mockito_test.dart
@@ -13,11 +13,13 @@
   String methodWithObjArgs(RealClass x) => "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";
+  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}) =>
+  String typeParameterizedNamedFn(List<int> w, List<int> x,
+          {List<int> y, List<int> z}) =>
       "Real";
   String get getter => "Real";
   void set setter(String arg) {
@@ -85,7 +87,6 @@
     });
   });
 
-
   group("mixin support", () {
     test("should work", () {
       var foo = new MockFoo();
@@ -143,16 +144,16 @@
       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: any)).thenReturn("x y");
       when(mock.methodWithTwoNamedArgs(any, z: any)).thenReturn("x z");
       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, z:17), 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, z: 17), isNull);
       when(mock.methodWithTwoNamedArgs(any, y: any, z: any))
           .thenReturn("x y z");
-      expect(mock.methodWithTwoNamedArgs(42, y:18, z:17), equals("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",
         () {
@@ -231,17 +232,19 @@
           .thenReturn("A lot!");
       expect(mock.typeParameterizedFn([42], [43], [44]), equals("A lot!"));
     });
-    test("should mock method with an optional typed arg matcher and an optional real arg", () {
+    test(
+        "should mock method with an optional typed arg matcher and an optional real arg",
+        () {
       when(mock.typeParameterizedFn(typed(any), typed(any), [44], typed(any)))
           .thenReturn("A lot!");
-      expect(mock.typeParameterizedFn([42], [43], [44], [45]), equals("A lot!"));
+      expect(
+          mock.typeParameterizedFn([42], [43], [44], [45]), equals("A lot!"));
     });
     test("should mock method with only some typed arg matchers", () {
       when(mock.typeParameterizedFn(typed(any), [43], typed(any)))
           .thenReturn("A lot!");
       expect(mock.typeParameterizedFn([42], [43], [44]), equals("A lot!"));
-      when(mock.typeParameterizedFn(typed(any), [43]))
-          .thenReturn("A bunch!");
+      when(mock.typeParameterizedFn(typed(any), [43])).thenReturn("A bunch!");
       expect(mock.typeParameterizedFn([42], [43]), equals("A bunch!"));
     });
     test("should throw when [typed] used alongside [null].", () {
@@ -252,47 +255,51 @@
     });
     test("should mock method when [typed] used alongside matched [null].", () {
       when(mock.typeParameterizedFn(
-          typed(any), argThat(equals(null)), typed(any)))
+              typed(any), argThat(equals(null)), typed(any)))
           .thenReturn("A lot!");
       expect(mock.typeParameterizedFn([42], null, [44]), equals("A lot!"));
     });
     test("should mock method with named, typed arg matcher", () {
-      when(mock.typeParameterizedNamedFn(
-          typed(any), [43], y: typed(any, named: "y")))
+      when(mock.typeParameterizedNamedFn(typed(any), [43],
+              y: typed(any, named: "y")))
           .thenReturn("A lot!");
-      expect(mock.typeParameterizedNamedFn([42], [43], y: [44]), equals("A lot!"));
+      expect(
+          mock.typeParameterizedNamedFn([42], [43], y: [44]), equals("A lot!"));
     });
-    test("should mock method with named, typed arg matcher and an arg matcher", () {
-      when(
-          mock.typeParameterizedNamedFn(
-              typed(any), [43],
+    test("should mock method with named, typed arg matcher and an arg matcher",
+        () {
+      when(mock.typeParameterizedNamedFn(typed(any), [43],
               y: typed(any, named: "y"), z: argThat(contains(45))))
           .thenReturn("A lot!");
       expect(mock.typeParameterizedNamedFn([42], [43], y: [44], z: [45]),
           equals("A lot!"));
     });
-    test("should mock method with named, typed arg matcher and a regular arg", () {
-      when(
-          mock.typeParameterizedNamedFn(
-              typed(any), [43],
-              y: typed(any, named: "y"), z: [45]))
-          .thenReturn("A lot!");
+    test("should mock method with named, typed arg matcher and a regular arg",
+        () {
+      when(mock.typeParameterizedNamedFn(typed(any), [43],
+          y: typed(any, named: "y"), z: [45])).thenReturn("A lot!");
       expect(mock.typeParameterizedNamedFn([42], [43], y: [44], z: [45]),
           equals("A lot!"));
     });
     test("should throw when [typed] used as a named arg, without `named:`", () {
-      expect(() => when(mock.typeParameterizedNamedFn(
-          typed(any), [43], y: typed(any))),
+      expect(
+          () => when(
+              mock.typeParameterizedNamedFn(typed(any), [43], y: typed(any))),
           throwsArgumentError);
     });
-    test("should throw when [typed] used as a positional arg, with `named:`", () {
-      expect(() => when(mock.typeParameterizedNamedFn(
-          typed(any), typed(any, named: "y"))),
+    test("should throw when [typed] used as a positional arg, with `named:`",
+        () {
+      expect(
+          () => when(mock.typeParameterizedNamedFn(
+              typed(any), typed(any, named: "y"))),
           throwsArgumentError);
     });
-    test("should throw when [typed] used as a named arg, with the wrong `named:`", () {
-      expect(() => when(mock.typeParameterizedNamedFn(
-          typed(any), [43], y: typed(any, named: "z"))),
+    test(
+        "should throw when [typed] used as a named arg, with the wrong `named:`",
+        () {
+      expect(
+          () => when(mock.typeParameterizedNamedFn(typed(any), [43],
+              y: typed(any, named: "z"))),
           throwsArgumentError);
     });
   });
@@ -344,9 +351,9 @@
       mock.methodWithObjArgs(m1);
       expectFail(
           "No matching calls. All calls: MockedClass.methodWithObjArgs(m1)",
-              () {
-            verify(mock.methodWithObjArgs(new MockedClass()));
-          });
+          () {
+        verify(mock.methodWithObjArgs(new MockedClass()));
+      });
       verify(mock.methodWithObjArgs(m1));
     });
     test("should mock method with list args", () {
@@ -376,10 +383,15 @@
     test("should mock method with argument matcher and capturer", () {
       mock.methodWithNormalArgs(50);
       mock.methodWithNormalArgs(100);
-      expect(verify(mock.methodWithNormalArgs(
-          captureThat(greaterThan(75)))).captured.single, equals(100));
-      expect(verify(mock
-              .methodWithNormalArgs(captureThat(lessThan(75)))).captured.single,
+      expect(
+          verify(mock.methodWithNormalArgs(captureThat(greaterThan(75))))
+              .captured
+              .single,
+          equals(100));
+      expect(
+          verify(mock.methodWithNormalArgs(captureThat(lessThan(75))))
+              .captured
+              .single,
           equals(50));
     });
     test("should mock method with mix of argument matchers and real things",
@@ -417,9 +429,12 @@
     test("should verify method with argument capturer", () {
       mock.typeParameterizedFn([50], [17]);
       mock.typeParameterizedFn([100], [17]);
-      expect(verify(mock.typeParameterizedFn(
-          typed(captureAny), [17])).captured,
-          equals([[50], [100]]));
+      expect(
+          verify(mock.typeParameterizedFn(typed(captureAny), [17])).captured,
+          equals([
+            [50],
+            [100]
+          ]));
     });
   });
   group("verify() qualifies", () {
@@ -580,21 +595,22 @@
     });
     test("should captureOut list arguments", () {
       mock.methodWithListArgs([42]);
-      expect(verify(
-          mock.methodWithListArgs(captureAny)).captured.single,
+      expect(verify(mock.methodWithListArgs(captureAny)).captured.single,
           equals([42]));
     });
     test("should captureOut multiple arguments", () {
       mock.methodWithPositionalArgs(1, 2);
-      expect(verify(
-              mock.methodWithPositionalArgs(captureAny, captureAny)).captured,
+      expect(
+          verify(mock.methodWithPositionalArgs(captureAny, captureAny))
+              .captured,
           equals([1, 2]));
     });
     test("should captureOut with matching arguments", () {
       mock.methodWithPositionalArgs(1);
       mock.methodWithPositionalArgs(2, 3);
-      expect(verify(
-              mock.methodWithPositionalArgs(captureAny, captureAny)).captured,
+      expect(
+          verify(mock.methodWithPositionalArgs(captureAny, captureAny))
+              .captured,
           equals([2, 3]));
     });
     test("should captureOut multiple invocations", () {
diff --git a/tool/travis.sh b/tool/travis.sh
index 5387de5..e22fa98 100755
--- a/tool/travis.sh
+++ b/tool/travis.sh
@@ -6,8 +6,10 @@
 # Verify that the libraries are error free.
 dartanalyzer --fatal-warnings \
   lib/mockito.dart \
+  lib/mockito_no_mirrors.dart \
+  lib/src/invocation_matcher.dart \
   test/mockito_test.dart
 
 # Run the tests.
-dart test/mockito_test.dart
-
+dart -c test/invocation_matcher_test.dart
+dart -c test/mockito_test.dart