unittest: refactor ahead of matcher changes

lib/unittest.dart

 // Copyright (c) 2013, 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 unittest;
 
 import 'dart:async';
 import 'dart:collection';
-import 'dart:isolate';
 
-import 'package:matcher/matcher.dart'
-    show
-        DefaultFailureHandler,
-        configureExpectFailureHandler,
-        TestFailure,
-        wrapAsync;
-export 'package:matcher/matcher.dart';
-
+import 'src/configuration.dart';
+import 'src/expect.dart';
 import 'src/utils.dart';
 
-import 'src/configuration.dart';
+export 'package:matcher/matcher.dart'
+    hide
+        completes,
+        completion,
+        configureExpectFailureHandler,
+        DefaultFailureHandler,
+        ErrorFormatter,
+        expect,
+        fail,
+        FailureHandler,
+        getOrCreateExpectFailureHandler,
+        prints,
+        TestFailure,
+        Throws,
+        throws,
+        throwsA,
+        throwsArgumentError,
+        throwsConcurrentModificationError,
+        throwsCyclicInitializationError,
+        throwsException,
+        throwsFormatException,
+        throwsNoSuchMethodError,
+        throwsNullThrownError,
+        throwsRangeError,
+        throwsStateError,
+        throwsUnimplementedError,
+        throwsUnsupportedError;
+
 export 'src/configuration.dart';
+export 'src/expect.dart';
+export 'src/simple_configuration.dart';
+export 'src/future_matchers.dart';
+export 'src/prints_matcher.dart';
+export 'src/throws_matcher.dart';
+export 'src/throws_matchers.dart';
 
-part 'src/simple_configuration.dart';
 part 'src/group_context.dart';
 part 'src/spread_args_helper.dart';
 part 'src/test_case.dart';
 part 'src/test_environment.dart';
 
 const Symbol _UNITTEST_ENVIRONMENT = #unittest.environment;
 
 final _TestEnvironment _defaultEnvironment = new _TestEnvironment();
 
 /**
@@ skipping 368 matching lines @@
 /// Lazily initializes the test library if not already initialized.
 void ensureInitialized() {
   _ensureInitialized(true);
 }
 
 void _ensureInitialized(bool configAutoStart) {
   if (_environment.initialized) {
     return;
   }
   _environment.initialized = true;
-  // Hook our async guard into the matcher library.
-  wrapAsync = (f, [id]) => expectAsync(f, id: id);
 
   _environment.uncaughtErrorMessage = null;
 
   unittestConfiguration.onInit();
 
   if (configAutoStart && _config.autoStart) {
     // Immediately queue the suite up. It will run after a timeout (i.e. after
     // main() has returned).
     scheduleMicrotask(runTests);
   }
@@ skipping 48 matching lines @@
 ///
 /// This allows for multiple invocations of the unittest library in the same
 /// application instance.
 /// This is useful when, for example, creating a test runner application which
 /// needs to create a new pristine test environment on each invocation to run
 /// a given set of test.
 dynamic withTestEnvironment(callback()) {
   return runZoned(callback,
       zoneValues: {_UNITTEST_ENVIRONMENT: new _TestEnvironment()});
 }