Changed the syntax some. All the handling of variable argument lists is

tests/lib/unittest/unittest_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.
 
 // TODO(gram):
 // Unfortunately I can't seem to test anything that involves timeouts, e.g.
 // insufficient callbacks, because the timeout is controlled externally
 // (test.dart?), and we would need to use a shorter timeout for the inner tests
 // so the outer timeout doesn't fire. So I removed all such tests.
 // I'd like to revisit this at some point.
@@ skipping 54 matching lines @@
   TestConfiguration(this._port);
 
   void onDone(int passed, int failed, int errors, List<TestCase> results,
       String uncaughtError) {
     var result = buildStatusString(passed, failed, errors, results, count,
         setup, teardown, uncaughtError);
     _port.send(result);
   }
 }
 
+class MockList extends Mock implements List {
+}
+
+class Foo {
+  bar(a, b, c) => a + b + c;
+}
+
+class FooSpy extends Mock implements Foo {
+  FooSpy real;
+  FooSpy() {
+    real = new Foo();
+    this.whenThereAre(callsTo('bar')).alwaysCall(real.bar);
+  }
+}
+
 runTest() {
   port.receive((testName, sendport) {
     configure(_testconfig = new TestConfiguration(sendport));
     if (testName == 'single correct test') {
       test(testName, () => expect(2 + 3, equals(5)));
     } else if (testName == 'single failing test') {
       test(testName, () => expect(2 + 2, equals(5)));
     } else if (testName == 'exception test') {
       test(testName, () { throw new Exception('fail'); });
     } else if (testName == 'group name test') {
@@ skipping 32 matching lines @@
       test(testName, () {
              var _callback;
              _callback = expectAsyncUntil0(() {
                if (++_testconfig.count < 10) {
                  _defer(_callback);
                }
              },
              () => (_testconfig.count == 10));
              _defer(_callback);
       });
+    } else if (testName == 'mock test 1 (Mock)') {
+      test(testName, () {
+        var m = new Mock();
+
+        m.whenThereAre(callsTo('Sum', 1, 2)).thenReturn('A').thenReturn('B');

[Siggi Cherem (dart-lang), 2012/06/28 00:44:40]

I'm playing around with other ideas to see if there is any that you like:
- m.whenThereIs(aCall('sum', 1, 2)).thenReturn('A')
- m.mock(callTo('sum', 1, 2)).returns('A')
- m.mock(aCallTo('sum', 1, 2)).returns('A')
- aCall(m, 'Sum', 1, 2).returns('A')
- mockCall(m, 'Sum', 1, 2).toReturn('A')

Also, we could overload the noSuchMethod so we can use it to record
expectations? (e.g. when we are done setting up, we can say m.readyToUse(); or
something):
- m.sum(1,2).returns('a')

+        m.whenThereAre(callsTo('Sum', 1, 1)).thenReturn('C');
+        m.whenThereAre(callsTo('Sum', anything, anything)).thenReturn('D');
+        m.whenThereAre(callsTo('Sub', anything, anything)).thenReturn('E');

[Siggi Cherem (dart-lang), 2012/06/28 00:44:40]

could we change the example to use lowercase method names instead :)?

[gram, 2012/06/28 17:32:54]

Done, and I changed the names to foo/bar which is more nebulous, as they
certainly don't do addition, etc.

+
+        var s = '${m.Sum(1,2)}${m.Sum(1,1)}${m.Sum(9,10)}'
+            '${m.Sub(1,1)}${m.Sum(1,2)}';
+        m.forThe(callsTo('Sum', anything, anything)).verify(calledExactly(4));

[Siggi Cherem (dart-lang), 2012/06/28 00:44:40]

Ideas instead of 'm.forThe(_).verify(_)'
- m.verify(_).that(_)
- m.veryfy(_).itWas(_)

+        m.forThe(callsTo('Sum', 1, anything)).verify(calledExactly(3));
+        m.forThe(callsTo('Sum', 9, anything)).verify(calledOnce);
+        m.forThe(callsTo('Sum', anything, 2)).verify(calledExactly(2));
+        expect(s, 'ACDEB');
+      });
+    } else if (testName == 'mock test 2 (MockList)') {
+      test(testName, () {
+        MockList l = new MockList();
+        l.whenThereAre(callsTo('length')).thenReturn(1);
+        l.whenThereAre(callsTo('add', anything)).alwaysReturn(0);
+        l.add('foo');
+        expect(l.length(), 1);
+
+        List m = new MockList();
+        m.whenThereAre(callsTo('add', anything)).alwaysReturn(0);
+
+        m.add('foo');
+        m.add('bar');
+
+        m.forThe(callsTo('add')).verify(calledExactly(2));
+        m.forThe(callsTo('add', 'foo')).verify(calledOnce);
+      });
+    } else if (testName == 'mock test 3 (Spy)') {
+      test(testName, () {
+        var p = new FooSpy();
+        p.bar(1, 2, 3);
+        p.forThe(callsTo('bar')).verify(calledOnce);
+        p.bar(2, 2, 2);
+        p.forThe(callsTo('bar')).verify(calledExactly(2));
+        p.forThe(callsTo('bar')).verify(sometimeReturned(6));
+        p.forThe(callsTo('bar')).verify(alwaysReturned(6));
+        p.forThe(callsTo('bar')).verify(neverReturned(5));
+        p.bar(2, 2, 1);
+        p.forThe(callsTo('bar')).verify(sometimeReturned(5));
+      });
     }
   });
 }
 
 void nextTest(int testNum) {
   SendPort sport = spawnFunction(runTest);
   sport.call(tests[testNum]).then((msg) {
     actual.add(msg);
     if (actual.length == expected.length) {
       for (var i = 0; i < tests.length; i++) {
         test(tests[i], () => expect(actual[i], equals(expected[i])));
       }
     } else {
       nextTest(testNum+1);
     }
   });
 }
 
 main() {
   tests = [
     'single correct test',
     'single failing test',
     'exception test',
     'group name test',
     'setup test',
     'teardown test',
     'setup and teardown test',
     'correct callback test',
     'excess callback test',
-    'completion test'
+    'completion test',
+    'mock test 1 (Mock)',
+    'mock test 2 (MockList)',
+    'mock test 3 (Spy)'
   ];
 
   expected = [
     buildStatusString(1, 0, 0, tests[0]),
     buildStatusString(0, 1, 0, tests[1], message: 'Expected: <5> but: was <4>'),
     buildStatusString(0, 1, 0, tests[2], message: 'Caught Exception: fail'),
     buildStatusString(2, 0, 0, 'a a::a b b'),
     buildStatusString(1, 0, 0, 'a ${tests[4]}', 0, 'setup'),
     buildStatusString(1, 0, 0, 'a ${tests[5]}', 0, '', 'teardown'),
     buildStatusString(1, 0, 0, 'a ${tests[6]}', 0,
         'setup', 'teardown'),
     buildStatusString(1, 0, 0, tests[7], 1),
     buildStatusString(0, 0, 1, tests[8], 1,
         message: 'Callback called more times than expected (2 > 1)'),
-    buildStatusString(1, 0, 0, tests[9], 10)
+    buildStatusString(1, 0, 0, tests[9], 10),
+    buildStatusString(1, 0, 0, tests[10]),
+    buildStatusString(1, 0, 0, tests[11]),
+    buildStatusString(1, 0, 0, tests[12])
   ];
 
   actual = [];
 
   nextTest(0);
 }