Added ability to disable logging in mocks, to avoid the memory overhead if you don't need behavior …

lib/unittest/unittest.dart

 // Copyright (c) 2011, 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.
 
 /**
  * A library for writing dart unit tests.
  *
  * To import this library, specify the relative path to
  * lib/unittest/unittest.dart.
  *
@@ skipping 342 matching lines @@
       _handleAllCallbacksDone();
     }
   }
 
   _allCallsDone() => _calls == _expectedCalls;
 
   _always() {
     // Always run except if the test is done.
     if (_testCase.isComplete) {
       _testCase.error(
-          'Callback called after already being marked as done ($_calls)',
+          'Callback called after already being marked as done ($_calls).',
           '');
       _state = _UNCAUGHT_ERROR;
       return false;
     } else {
       return true;
     }
   }
 
   invoke([arg0 = _sentinel, arg1 = _sentinel, arg2 = _sentinel,
           arg3 = _sentinel, arg4 = _sentinel]) {
     return guardAsync(() {
       ++_calls;
       if (!_shouldCallBack()) {
         return;
       } else if (arg0 == _sentinel) {
         return _callback();
       } else if (arg1 == _sentinel) {
         return _callback(arg0);
       } else if (arg2 == _sentinel) {
         return _callback(arg0, arg1);
       } else if (arg3 == _sentinel) {
         return _callback(arg0, arg1, arg2);
       } else if (arg4 == _sentinel) {
         return _callback(arg0, arg1, arg2, arg3);
       } else {
         _testCase.error(
-           'unittest lib does not support callbacks with more than 4 arguments',
+           'unittest lib does not support callbacks with more than'
+              ' 4 arguments.',
            '');
         _state = _UNCAUGHT_ERROR;
       }
     },
     _after);
   }
 
   invoke0() {
     return guardAsync(
         () {
@@ skipping 25 matching lines @@
           }
         },
         _after);
   }
 
   /** Returns false if we exceded the number of expected calls. */
   bool _checkCallCount() {
     if (_calls > _expectedCalls) {
       _testCase.error(
           'Callback called more times than expected '
-             '($_calls > $_expectedCalls)',
+             '($_calls > $_expectedCalls).',
           '');
       _state = _UNCAUGHT_ERROR;
       return false;
     }
     return true;
   }
 }
 
 /**
  * Indicate that [callback] is expected to be called a [count] number of times
@@ skipping 138 matching lines @@
   // which is recursively invoked in the case of async tests that
   // run synchronously. Bad things can then happen.
   _defer(() {
     _callbacksCalled++;
     if (_currentTest < _tests.length) {
       final testCase = _tests[_currentTest];
       if (_callbacksCalled > testCase.callbacks) {
         final expected = testCase.callbacks;
         testCase.error(
             'More calls to _handleAllCallbacksDone() than expected. '
-            'Actual: ${_callbacksCalled}, expected: ${expected}', '');
+            'Actual: ${_callbacksCalled}, expected: ${expected}.', '');
         _state = _UNCAUGHT_ERROR;
       } else if ((_callbacksCalled == testCase.callbacks) &&
           (_state != _RUNNING_TEST)) {
         if (testCase.result == null) {
           testCase.pass();
         }
         _currentTest++;
         _testRunner();
       }
     }
@@ skipping 171 matching lines @@
   _config.onInit();
 
   // Immediately queue the suite up. It will run after a timeout (i.e. after
   // main() has returned).
   _defer(_runTests);
 }
 
 /** Signature for a test function. */
 typedef void TestFunction();