step 1 in making unittest platform independent.

lib/unittest/shared.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.
 
+Configuration _config = null;
+
 /**
  * Description text of the current test group. If multiple groups are nested,
  * this will contain all of their text concatenated.
  */
 String _currentGroup = '';
 
 /** Tests executed in this suite. */
 List<TestCase> _tests;
 
 /**
  * Callback used to run tests. Entrypoints can replace this with their own
  * if they want.
  */
 Function _testRunner;
 
-/** Whether this is run within dartium layout tests. */
-bool _isLayoutTest = false;
-
 /** Current test being executed. */
 int _currentTest = 0;
 
 /** Total number of callbacks that have been executed in the current test. */
 int _callbacksCalled = 0;
 
 final _UNINITIALIZED = 0;
 final _READY         = 1;
 final _RUNNING_TEST  = 2;
 
@@ skipping 46 matching lines @@
   final testCase = new TestCase(
       _tests.length + 1, _fullSpec(spec), body, callbacks);
   _tests.add(testCase);
 
   if (callbacks < 1) {
     testCase.error(
         'Async tests must wait for at least one callback ', '');
   }
 }
 
-void serialInvokeAsync(List closures) {
-  final length = closures.length;
-  if (length > 0) {
-    int i = 0;
-    void invokeNext() {
-      closures[i]();
-      i++;
-      if (i < length) {
-        window.setTimeout(invokeNext, 0);
-      }
-    }
-    window.setTimeout(invokeNext, 0);
-  }
-}
-
 /**
  * Creates a new named group of tests. Calls to group() or test() within the
  * body of the function passed to this will inherit this group's description.
  */
 void group(String description, void body()) {
   _ensureInitialized();
 
   // Concatenate the new group.
   final oldGroup = _currentGroup;
   if (_currentGroup != '') {
@@ skipping 27 matching lines @@
         + 'Actual: ${_callbacksCalled}, expected: ${expected}', '');
     _state = _UNCAUGHT_ERROR;
   } else if ((_callbacksCalled == testCase.callbacks) &&
       (_state != _RUNNING_TEST)) {
     testCase.pass();
     _currentTest++;
     _testRunner();
   }
 }
 
-void forLayoutTests() {
-  _isLayoutTest = true;
+/** Runs [callback] at the end of the event loop. */
+_defer(void callback()) {
+  // Exploit isolate ports as a platform-independent mechanism to queue a
+  // message at the end of the event loop.
+  // TODO(sigmund): expose this functionality somewhere in our libraries.
+  final port = new ReceivePort();
+  port.receive((msg, reply) {
+    callback();
+    port.close();
+  });
+  port.toSendPort().send(null, null);
 }
 
 /** Runs all queued tests, one at a time. */
 _runTests() {
-  _platformStartTests();
+  _config.onStart();
 
-  _platformDefer(() {
+  _defer(() {
     assert (_currentTest == 0);
     _testRunner();
   });
 }
 
 /** Runs a single test. */
 _runTest(TestCase testCase) {
   try {
     _callbacksCalled = 0;
     _state = _RUNNING_TEST;
@@ skipping 49 matching lines @@
   int testsErrors_ = 0;
 
   for (TestCase t in _tests) {
     switch (t.result) {
       case _PASS:  testsPassed_++; break;
       case _FAIL:  testsFailed_++; break;
       case _ERROR: testsErrors_++; break;
     }
   }
 
-  _platformCompleteTests(testsPassed_, testsFailed_, testsErrors_);
+  _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests);
 }
 
 String _fullSpec(String spec) {
   if (spec === null) return '$_currentGroup';
   return _currentGroup != '' ? '$_currentGroup $spec' : spec;
 }
 
 /**
  * Lazily initializes the test library if not already initialized.
  */
 _ensureInitialized() {
   if (_state != _UNINITIALIZED) return;
 
   _tests = <TestCase>[];
   _currentGroup = '';
   _state = _READY;
   _testRunner = _nextBatch;
 
-  _platformInitialize();
+  if (_config == null) {
+    _config = _defaultConfig();
+  }
+  _config.onInit();
 
   // Immediately queue the suite up. It will run after a timeout (i.e. after
   // main() has returned).
-  _platformDefer(_runTests);
+  _defer(_runTests);
 }
 
 /**
  * Wraps an value and provides an "==" operator that can be used to verify that
  * the value matches a given expectation.
  */
 class Expectation {
   final _value;
 
   Expectation(this._value);
@@ skipping 101 matching lines @@
   }
 
   void error(String message_, String stackTrace_) {
     result = _ERROR;
     this.message = message_;
     this.stackTrace = stackTrace_;
   }
 }
 
 typedef void TestFunction();