Rename the package to "test".

lib/src/frontend/expect_async.dart

 // Copyright (c) 2015, 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.frontend.expect_async;
+library test.frontend.expect_async;
 
 import '../backend/invoker.dart';
 import '../backend/state.dart';
 import 'expect.dart';
 
 /// An object used to detect unpassed arguments.
 const _PLACEHOLDER = const Object();
 
 // Functions used to check how many arguments a callback takes.
 typedef _Func0();
@@ skipping 139 matching lines @@
 
   _max5([a0 = _PLACEHOLDER, a1 = _PLACEHOLDER, a2 = _PLACEHOLDER,
       a3 = _PLACEHOLDER, a4 = _PLACEHOLDER]) => _max6(a0, a1, a2, a3, a4);
 
   _max6([a0 = _PLACEHOLDER, a1 = _PLACEHOLDER, a2 = _PLACEHOLDER,
       a3 = _PLACEHOLDER, a4 = _PLACEHOLDER, a5 = _PLACEHOLDER]) =>
       _run([a0, a1, a2, a3, a4, a5].where((a) => a != _PLACEHOLDER));
 
   /// Runs the wrapped function with [args] and returns its return value.
   _run(Iterable args) {
-    // Note that in the old unittest, this returned `null` if it encountered an
+    // Note that in the old test, this returned `null` if it encountered an
     // error, where now it just re-throws that error because Zone machinery will
     // pass it to the invoker anyway.
     try {
       _actualCalls++;
       if (_invoker.liveTest.isComplete &&
           _invoker.liveTest.state.result == Result.success) {
         throw 'Callback ${_id}called ($_actualCalls) after test case '
               '${_invoker.liveTest.test.name} had already completed.$_reason';
       } else if (_maxExpectedCalls >= 0 && _actualCalls > _maxExpectedCalls) {
         throw new TestFailure('Callback ${_id}called more times than expected '
@@ skipping 18 matching lines @@
     // Mark this callback as complete and remove it from the test case's
     // oustanding callback count; if that hits zero the test is done.
     _complete = true;
     _invoker.removeOutstandingCallback();
   }
 }
 
 /// Indicate that [callback] is expected to be called [count] number of times
 /// (by default 1).
 ///
-/// The unittest framework will wait for the callback to run the [count] times
+/// The test framework will wait for the callback to run the [count] times
 /// before it considers the current test to be complete. [callback] may take up
 /// to six optional or required positional arguments; named arguments are not
 /// supported.
 ///
 /// [max] can be used to specify an upper bound on the number of calls; if this
 /// is exceeded the test will fail. If [max] is `0` (the default), the callback
 /// is expected to be called exactly [count] times. If [max] is `-1`, the
 /// callback is allowed to be called any number of times greater than [count].
 ///
 /// Both [id] and [reason] are optional and provide extra information about the
@@ skipping 10 matching lines @@
 /// true will the callback be considered complete. [callback] may take up to six
 /// optional or required positional arguments; named arguments are not
 /// supported.
 ///
 /// Both [id] and [reason] are optional and provide extra information about the
 /// callback when debugging. [id] should be the name of the callback, while
 /// [reason] should be the reason the callback is expected to be called.
 Function expectAsyncUntil(Function callback, bool isDone(),
     {String id, String reason}) => new _ExpectedFunction(callback, 0, -1,
         id: id, reason: reason, isDone: isDone).func;