pkg/mock: fixes for v0.11

pkg/mock/test/mock_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library mock.test;
 
 import 'package:unittest/unittest.dart' show test, group, skip_test;
 import 'package:matcher/matcher.dart';
 import 'package:mock/mock.dart';
 
@@ skipping 18 matching lines @@
 LogEntry makeTestLogEntry(String methodName, List args, int time,
                  [String mockName]) {
   LogEntry e = new LogEntry(mockName, methodName, args, Action.IGNORE);
   e.time = new DateTime.fromMillisecondsSinceEpoch(time, isUtc: true);
   return e;
 }
 
 LogEntryList makeTestLog() {
   var args = new List();
   return new LogEntryList('test')
-    ..add(makeTestLogEntry('a', args, 1000))
-    ..add(makeTestLogEntry('b', args, 2000))
-    ..add(makeTestLogEntry('c', args, 3000));
+      ..add(makeTestLogEntry('a', args, 1000))
+      ..add(makeTestLogEntry('b', args, 2000))
+      ..add(makeTestLogEntry('c', args, 3000));
 }
 
 void main() {
   test('Mocking: Basics', () {
     var m = new Mock();
     // intentional no-opp access to m.length
     var foo = m.length;
     m.getLogs(callsTo('get length')).verify(happenedOnce);
 
     m.when(callsTo('foo', 1, 2)).thenReturn('A').thenReturn('B');
     m.when(callsTo('foo', 1, 1)).thenReturn('C');
     m.when(callsTo('foo', 9, anything)).thenReturn('D');
     m.when(callsTo('bar', anything, anything)).thenReturn('E');
     m.when(callsTo('foobar')).thenReturn('F');
 
     var s = '${m.foo(1,2)}${m.foo(1,1)}${m.foo(9,10)}'
         '${m.bar(1,1)}${m.foo(1,2)}';
-    m.getLogs(callsTo('foo', anything, anything)).
-        verify(happenedExactly(4));
+    m.getLogs(callsTo('foo', anything, anything)).verify(happenedExactly(4));
     m.getLogs(callsTo('foo', 1, anything)).verify(happenedExactly(3));
     m.getLogs(callsTo('foo', 9, anything)).verify(happenedOnce);
     m.getLogs(callsTo('foo', anything, 2)).verify(happenedExactly(2));
     m.getLogs(callsTo('foobar')).verify(neverHappened);
     m.getLogs(callsTo('foo', 10, anything)).verify(neverHappened);
     m.getLogs(callsTo('foo'), returning(anyOf('A', 'C'))).
         verify(happenedExactly(2));
     expect(s, 'ACDEB');
   });
 
@@ skipping 79 matching lines @@
   test('Mocking: No behavior', () {
     var m = new Mock.custom(throwIfNoBehavior:true);
     m.when(callsTo('foo')).thenReturn(null);
     expect(() => m.foo(), returnsNormally);
     expect(() => m.bar(), throwsA((e) => e.toString() ==
         'Exception: No behavior specified for method bar.'));
   });
 
   test('Mocking: Shared logList', () {
     var logList = new LogEntryList();
-    var m1 = new Mock.custom(name:'m1', log:logList);
-    var m2 = new Mock.custom(name:'m2', log:logList);
+    var m1 = new Mock.custom(name: 'm1', log: logList);
+    var m2 = new Mock.custom(name: 'm2', log: logList);
     m1.foo();
     m2.foo();
     m1.bar();
     m2.bar();
     expect(logList.logs.length, 4);
     logList.getMatches(anything, callsTo('foo')).verify(happenedExactly(2));
     logList.getMatches('m1', callsTo('foo')).verify(happenedOnce);
     logList.getMatches('m1', callsTo('bar')).verify(happenedOnce);
     m2.getLogs(callsTo('foo')).verify(happenedOnce);
     m2.getLogs(callsTo('bar')).verify(happenedOnce);
@@ skipping 267 matching lines @@
     logList.add(e10);
 
     LogEntryList keyList = new LogEntryList('keys');
 
     // Test with empty key list.
 
     LogEntryList result;
     result = logList.preceding(keyList);
     expect(result.logs, hasLength(0));
 
-    result = logList.preceding(keyList, includeKeys:true);
+    result = logList.preceding(keyList, includeKeys: true);
     expect(result.logs, hasLength(0));
 
     // Single key, distance 1, no restrictions.
 
     keyList.add(e3);
     result = logList.preceding(keyList);
     expect(result.logs, orderedEquals([e2]));
 
     result = logList.following(keyList);
     expect(result.logs, orderedEquals([e4]));
 
     // Single key, distance 2, no restrictions.
 
-    result = logList.preceding(keyList, distance:2);
+    result = logList.preceding(keyList, distance: 2);
     expect(result.logs, orderedEquals([e1, e2]));
 
-    result = logList.following(keyList, distance:2);
+    result = logList.following(keyList, distance: 2);
     expect(result.logs, orderedEquals([e4, e5]));
 
     // Single key, distance 3, no restrictions.
 
-    result = logList.preceding(keyList, distance:3);
+    result = logList.preceding(keyList, distance: 3);
     expect(result.logs, orderedEquals([e0, e1, e2]));
 
-    result = logList.following(keyList, distance:3);
+    result = logList.following(keyList, distance: 3);
     expect(result.logs, orderedEquals([e4, e5, e6]));
 
     // Include keys in result
 
-    result = logList.preceding(keyList, distance:3, includeKeys:true);
+    result = logList.preceding(keyList, distance: 3, includeKeys: true);
     expect(result.logs, orderedEquals([e0, e1, e2, e3]));
 
-    result = logList.following(keyList, distance:3, includeKeys:true);
+    result = logList.following(keyList, distance: 3, includeKeys: true);
     expect(result.logs, orderedEquals([e3, e4, e5, e6]));
 
     // Restrict the matches
 
     result = logList.preceding(keyList, logFilter:callsTo(startsWith('bar')),
       distance:3);
     expect(result.logs, orderedEquals([e1, e2]));
 
     result = logList.preceding(keyList, logFilter:callsTo(startsWith('bar')),
         distance:3, includeKeys:true);
@@ skipping 11 matching lines @@
     keyList.add(e0);
     keyList.add(e3);
     keyList.add(e7);
 
     result = logList.preceding(keyList);
     expect(result.logs, orderedEquals([e2, e6]));
 
     result = logList.following(keyList);
     expect(result.logs, orderedEquals([e1, e4, e8]));
 
-    result = logList.preceding(keyList, includeKeys:true);
+    result = logList.preceding(keyList, includeKeys: true);
     expect(result.logs, orderedEquals([e0, e2, e3, e6, e7]));
 
-    result = logList.following(keyList, includeKeys:true);
+    result = logList.following(keyList, includeKeys: true);
     expect(result.logs, orderedEquals([e0, e1, e3, e4, e7, e8]));
 
     keyList.logs.clear();
     keyList.add(e3);
     keyList.add(e7);
     keyList.add(e10);
 
     result = logList.preceding(keyList);
     expect(result.logs, orderedEquals([e2, e6, e9]));
 
     result = logList.following(keyList);
     expect(result.logs, orderedEquals([e4, e8]));
 
-    result = logList.preceding(keyList, includeKeys:true);
+    result = logList.preceding(keyList, includeKeys: true);
     expect(result.logs, orderedEquals([e2, e3, e6, e7, e9, e10]));
 
-    result = logList.following(keyList, includeKeys:true);
+    result = logList.following(keyList, includeKeys: true);
     expect(result.logs, orderedEquals([e3, e4, e7, e8, e10]));
 
     keyList.logs.clear();
     keyList.add(e0);
     keyList.add(e3);
     keyList.add(e7);
     keyList.add(e10);
 
     result = logList.preceding(keyList);
     expect(result.logs, orderedEquals([e2, e6, e9]));
 
     result = logList.following(keyList);
     expect(result.logs, orderedEquals([e1, e4, e8]));
 
-    result = logList.preceding(keyList, includeKeys:true);
+    result = logList.preceding(keyList, includeKeys: true);
     expect(result.logs, orderedEquals([e0, e2, e3, e6, e7, e9, e10]));
 
-    result = logList.following(keyList, includeKeys:true);
+    result = logList.following(keyList, includeKeys: true);
     expect(result.logs, orderedEquals([e0, e1, e3, e4, e7, e8, e10]));
 
     keyList.logs.clear();
     keyList.add(e0);
     keyList.add(e3);
     keyList.add(e7);
 
-    result = logList.preceding(keyList, distance:3);
+    result = logList.preceding(keyList, distance: 3);
     expect(result.logs, orderedEquals([e1, e2, e4, e5, e6]));
 
-    result = logList.following(keyList, distance:3);
+    result = logList.following(keyList, distance: 3);
     expect(result.logs, orderedEquals([e1, e2, e4, e5, e6, e8, e9, e10]));
 
-    result = logList.preceding(keyList, distance:3, includeKeys:true);
+    result = logList.preceding(keyList, distance: 3, includeKeys: true);
     expect(result.logs, orderedEquals([e0, e1, e2, e3, e4, e5, e6, e7]));
 
     result = logList.following(keyList, distance:3, includeKeys:true);
     expect(result.logs, orderedEquals([e0, e1, e2, e3, e4, e5, e6,
                                        e7, e8, e9, e10]));
 
     keyList.logs.clear();
     keyList.add(e3);
     keyList.add(e7);
     keyList.add(e10);
 
-    result = logList.preceding(keyList, distance:3);
+    result = logList.preceding(keyList, distance: 3);
     expect(result.logs, orderedEquals([e0, e1, e2, e4, e5, e6, e8, e9]));
 
-    result = logList.following(keyList, distance:3);
+    result = logList.following(keyList, distance: 3);
     expect(result.logs, orderedEquals([e4, e5, e6, e8, e9]));
 
     result = logList.preceding(keyList, distance:3, includeKeys:true);
     expect(result.logs, orderedEquals([e0, e1, e2, e3, e4, e5, e6,
                                        e7, e8, e9, e10]));
 
-    result = logList.following(keyList, distance:3, includeKeys:true);
+    result = logList.following(keyList, distance: 3, includeKeys: true);
     expect(result.logs, orderedEquals([e3, e4, e5, e6, e7, e8, e9, e10]));
 
     keyList.logs.clear();
     keyList.add(e0);
     keyList.add(e3);
     keyList.add(e7);
     keyList.add(e10);
 
-    result = logList.preceding(keyList, distance:3);
+    result = logList.preceding(keyList, distance: 3);
     expect(result.logs, orderedEquals([e1, e2, e4, e5, e6, e8, e9]));
 
-    result = logList.following(keyList, distance:3);
+    result = logList.following(keyList, distance: 3);
     expect(result.logs, orderedEquals([e1, e2, e4, e5, e6, e8, e9]));
 
     result = logList.preceding(keyList, distance:3, includeKeys:true);
     expect(result.logs, orderedEquals([e0, e1, e2, e3, e4, e5, e6,
                                        e7, e8, e9, e10]));
 
     result = logList.following(keyList, distance:3, includeKeys:true);
     expect(result.logs, orderedEquals([e0, e1, e2, e3, e4, e5, e6,
                                        e7, e8, e9, e10]));
   });
 
   test('Mocking: stepwiseValidate', () {
     LogEntryList logList = new LogEntryList('test');
     for (var i = 0; i < 10; i++) {
       LogEntry e = new LogEntry(null, 'foo', [i], Action.IGNORE);
       logList.add(e);
     }
     int total = 0;
     logList.stepwiseValidate((log, pos) {
-        total += log[pos].args[0] * log[pos + 1].args[0];
-        expect(log[pos + 1].args[0] - log[pos].args[0], equals(1));
-        return 2;
+      total += log[pos].args[0] * log[pos + 1].args[0];
+      expect(log[pos + 1].args[0] - log[pos].args[0], equals(1));
+      return 2;
     });
     expect(total, equals((0 * 1) + (2 * 3) + (4 * 5) + (6 * 7) + (8 * 9)));
   });
 
   test('Mocking: clearLogs', () {
     var m = new Mock();
     m.foo();
     m.foo();
     m.foo();
     expect(m.log.logs, hasLength(3));
@@ skipping 10 matching lines @@
     }
     expect(log.logs, hasLength(9));
     m1.clearLogs();
     expect(log.logs, hasLength(6));
     m1.clearLogs();
     expect(log.logs, hasLength(6));
     expect(log.logs.every((e) => e.mockName == 'm2' || e.mockName == 'm3'),
         isTrue);
     m2.clearLogs();
     expect(log.logs, hasLength(3));
-    expect(log.logs.every((e) => e.mockName =='m3'), isTrue);
+    expect(log.logs.every((e) => e.mockName == 'm3'), isTrue);
     m3.clearLogs();
     expect(log.logs, hasLength(0));
   });
 
   // TODO(kevmoo): figure out why this test is failing
   skip_test("Mocking: instances", () {
     var alice = new Object();
     var bob = new Object();
     var m = new Mock();
     m.when(callsTo("foo", alice)).alwaysReturn(true);
@@ skipping 64 matching lines @@
   test('Spys', () {
     var real = new Foo();
     var spy = new Mock.spy(real);
     var sum = spy.sum(1, 2, 3);
     expect(sum, 6);
     expect(() => spy.total(1, 2, 3), throwsNoSuchMethodError);
     spy.getLogs(callsTo('sum')).verify(happenedExactly(1));
     spy.getLogs(callsTo('total')).verify(happenedExactly(1));
   });
 }