Run dartfmt on remaining unformated pkg packages

pkg/typed_mock/lib/typed_mock.dart

 library typed_mock;
 
-
 _InvocationMatcher _lastMatcher;
 
 /// Enables stubbing methods.
 ///
 /// Use it when you want the mock to return a particular value when a particular
 /// method, getter or setter is called.
 ///
 ///     when(obj.testProperty).thenReturn(10);
 ///     expect(obj.testProperty, 10); // pass
 ///
@@ skipping 18 matching lines @@
     // set behavior
     var behavior = new Behavior._(_lastMatcher);
     _lastMatcher._behavior = behavior;
     return behavior;
   } finally {
     // clear to prevent memory leak
     _lastMatcher = null;
   }
 }
 
-
 /// Clears all interactions remembered so far.
 resetInteractions(TypedMock mock) {
   mock._invocations.clear();
   mock._verifiedInvocations.clear();
 }
 
-
 /// Verifies certain behavior happened a specified number of times.
 Verifier verify(_ignored) {
   try {
     var mock = _lastMatcher._mock;
     mock._removeLastInvocation();
     // set verifier
     return new Verifier._(mock, _lastMatcher);
   } finally {
     // clear to prevent memory leak
     _lastMatcher = null;
   }
 }
 
-
 /// Verifies that the given mock doesn't have any unverified interaction.
 void verifyNoMoreInteractions(TypedMock mock) {
   var notVerified = mock._computeNotVerifiedInvocations();
   // OK
   if (notVerified.isEmpty) {
     return;
   }
   // fail
   var invocationsString = _getInvocationsString(notVerified);
   throw new VerifyError('Unexpected interactions:\n$invocationsString');
 }
 
-
 /// Verifies that no interactions happened on the given mock.
 void verifyZeroInteractions(TypedMock mock) {
   var invocations = mock._invocations;
   // OK
   if (invocations.isEmpty) {
     return;
   }
   // fail
   var invocationsString = _getInvocationsString(invocations);
   throw new VerifyError('Unexpected interactions:\n$invocationsString');
 }
 
-
 /// [VerifyError] is thrown when one of the [verify] checks fails.
 class VerifyError {
   final String message;
   VerifyError(this.message);
   String toString() => 'VerifyError: $message';
 }
 
-
 String _getInvocationsString(Iterable<Invocation> invocations) {
   var buffer = new StringBuffer();
   invocations.forEach((invocation) {
     var member = invocation.memberName;
     buffer.write(member);
     buffer.write(' ');
     buffer.write(invocation.positionalArguments);
     buffer.write(' ');
     buffer.write(invocation.namedArguments);
     buffer.writeln();
   });
   return buffer.toString();
 }
 
-
 class _InvocationMatcher {
   final Symbol _member;
   final TypedMock _mock;
   final List<ArgumentMatcher> _matchers = [];
 
   Behavior _behavior;
 
   _InvocationMatcher(this._mock, this._member, Invocation invocation) {
     invocation.positionalArguments.forEach((argument) {
       ArgumentMatcher matcher;
@@ skipping 15 matching lines @@
       var matcher = _matchers[i];
       var argument = arguments[i];
       if (!matcher.matches(argument)) {
         return false;
       }
     }
     return true;
   }
 }
 
-
 class Behavior {
   final _InvocationMatcher _matcher;
 
   Behavior._(this._matcher);
 
   bool _thenFunctionEnabled = false;
   Function _thenFunction;
 
   bool _returnAlwaysEnabled = false;
   var _returnAlways;
@@ skipping 66 matching lines @@
     }
     // exception
     if (_throwExceptionEnabled) {
       throw _throwException;
     }
     // no value
     return null;
   }
 }
 
-
 class Verifier {
   final TypedMock _mock;
   final _InvocationMatcher _matcher;
 
   Verifier._(this._mock, this._matcher);
 
   /// Marks matching interactions as verified and never fails.
   void any() {
     // mark as verified, but don't check the actual count
     _count();
@@ skipping 60 matching lines @@
       if (!_matcher.match(invocation)) {
         return;
       }
       _mock._verifiedInvocations.add(invocation);
       times++;
     });
     return times;
   }
 }
 
-
 /// A class to extend mocks from.
 /// It supports specifying behavior using [when] and validation of interactions
 /// using [verify].
 ///
 ///     abstract class Name {
 ///       String get firstName;
 ///       String get lastName;
 ///     }
 ///     class NameMock extends TypedMock implements Name {
 ///       noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
@@ skipping 34 matching lines @@
   Iterable<Invocation> _computeNotVerifiedInvocations() {
     notVerified(e) => !_verifiedInvocations.contains(e);
     return _invocations.where(notVerified);
   }
 
   void _removeLastInvocation() {
     _invocations.removeLast();
   }
 }
 
-
 /// [ArgumentMatcher] checks whether the given argument satisfies some
 /// condition.
 abstract class ArgumentMatcher {
   const ArgumentMatcher();
 
   /// Checks whether this matcher accepts the given argument.
   bool matches(val);
 }
 
-
 class _ArgumentMatcher_equals extends ArgumentMatcher {
   final expected;
 
   const _ArgumentMatcher_equals(this.expected);
 
   @override
   bool matches(val) {
     return val == expected;
   }
 }
 
-
 class _ArgumentMatcher_anyBool extends ArgumentMatcher {
   const _ArgumentMatcher_anyBool();
 
   @override
   bool matches(val) {
     return val is bool;
   }
 }
 
 /// Matches any [bool] value.
 final anyBool = const _ArgumentMatcher_anyBool() as dynamic;
 
-
 class _ArgumentMatcher_anyInt extends ArgumentMatcher {
   const _ArgumentMatcher_anyInt();
 
   @override
   bool matches(val) {
     return val is int;
   }
 }
 
 /// Matches any [int] value.
 final anyInt = const _ArgumentMatcher_anyInt() as dynamic;
 
-
 class _ArgumentMatcher_anyObject extends ArgumentMatcher {
   const _ArgumentMatcher_anyObject();
 
   @override
   bool matches(val) {
     return true;
   }
 }
 
 /// Matches any [Object] (or subclass) value.
 final anyObject = const _ArgumentMatcher_anyObject() as dynamic;
 
-
 class _ArgumentMatcher_anyString extends ArgumentMatcher {
   const _ArgumentMatcher_anyString();
 
   @override
   bool matches(val) {
     return val is String;
   }
 }
 
 /// Matches any [String] value.
 final anyString = const _ArgumentMatcher_anyString() as dynamic;