Revert "Remove package:unittest from some tests"

This reverts commit dde47b2aad.

Revert "Update Dartium status for passing test"

This reverts commit d71c70d56d.

Tests failing on dart2js and async_star_pause_test is
passing on Dartium. Need to think about how to update the
status files.

Review-Url: https://codereview.chromium.org/2656503004 .

tests/language/async_await_test.dart

@@ -4,7 +4,9 @@
 
 library async_await_test;
 
-import "package:test/test.dart";
+// Use of package:unittest and package:test is deprecated in sdk/tests.
+// Do not add any more uses of this package.
+import "package:unittest/unittest.dart";
 import "dart:async";
 
 main() {

tests/language/async_star_pause_test.dart

@@ -4,7 +4,7 @@
 
 library async_star_pause_test;
 
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 import "dart:async";
 
 main() {

tests/language/async_star_test.dart

@@ -4,7 +4,7 @@
 
 library async_star_test;
 
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 import "dart:async";
 
 main() {

tests/language/language.status

@@ -8,6 +8,8 @@
 # These test entries will be valid for vm/dartium (with and without kernel).
 [ $compiler == none || $compiler == app_jit || $compiler == dartk || $runtime == dart_precompiled ]
 async_star_cancel_while_paused_test: RuntimeError
+# This is OK for now, but we may want to change the semantics to match the test.
+async_star_pause_test: Fail, OK
 
 # These tests are skipped in the VM because it has "--supermixin"
 # functionality enabled unconditionally.  The tests should be removed

tests/lib/async/first_regression_test.dart

@@ -6,7 +6,7 @@
 
 library first_regression_test;
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 class DoubleTransformer<T> implements StreamTransformer<T, T> {
   Stream<T> bind(Stream<T> stream) {

tests/lib/async/future_timeout_test.dart

@@ -5,7 +5,7 @@
 library future_timeout_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("timeoutNoComplete", () {

tests/lib/async/multiple_timer_test.dart

@@ -5,7 +5,7 @@
 library multiple_timer_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 const Duration TIMEOUT1 = const Duration(seconds: 1);
 const Duration TIMEOUT2 = const Duration(seconds: 2);

tests/lib/async/schedule_microtask2_test.dart

@@ -4,8 +4,9 @@
 
 library run_async_test;
 
+import 'package:expect/expect.dart';
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   // Check that the callbacks are executed in order.
@@ -13,7 +14,7 @@ main() {
     int lastCallback = -1;
     for (int i = 0; i < 100; i++) {
       scheduleMicrotask(expectAsync(() {
-        expect(lastCallback, equals(i - 1));
+        Expect.equals(lastCallback, i - 1);
         lastCallback = i;
       }));
     }

tests/lib/async/schedule_microtask3_test.dart

@@ -5,7 +5,8 @@
 library run_async_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:expect/expect.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("run async timer after async test", () {
@@ -15,7 +16,7 @@ main() {
     Timer.run(expectAsync(() { timerCallbackExecuted = true; }));
 
     scheduleMicrotask(expectAsync(() {
-      expect(timerCallbackExecuted, isFalse);
+      Expect.isFalse(timerCallbackExecuted);
     }));
 
     scheduleMicrotask(expectAsync(() {
@@ -27,12 +28,12 @@ main() {
       }
       if (sum == 0) throw "bad";  // Just to use the result.
       scheduleMicrotask(expectAsync(() {
-        expect(timerCallbackExecuted, isFalse);
+        Expect.isFalse(timerCallbackExecuted);
       }));
     }));
 
     scheduleMicrotask(expectAsync(() {
-      expect(timerCallbackExecuted, isFalse);
+      Expect.isFalse(timerCallbackExecuted);
     }));
   });
 }

tests/lib/async/schedule_microtask5_test.dart

@@ -4,8 +4,9 @@
 
 library run_async_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("run async timer after async test", () {
@@ -13,13 +14,13 @@ main() {
     bool timerCallbackExecuted = false;
 
     scheduleMicrotask(expectAsync(() {
-      expect(timerCallbackExecuted, isFalse);
+      Expect.isFalse(timerCallbackExecuted);
     }));
 
     Timer.run(expectAsync(() { timerCallbackExecuted = true; }));
 
     scheduleMicrotask(expectAsync(() {
-      expect(timerCallbackExecuted, isFalse);
+      Expect.isFalse(timerCallbackExecuted);
     }));
 
     scheduleMicrotask(expectAsync(() {
@@ -31,12 +32,12 @@ main() {
       }
       if (sum == 0) throw "bad";  // Just to use the result.
       scheduleMicrotask(expectAsync(() {
-        expect(timerCallbackExecuted, isFalse);
+        Expect.isFalse(timerCallbackExecuted);
       }));
     }));
 
     scheduleMicrotask(expectAsync(() {
-      expect(timerCallbackExecuted, isFalse);
+      Expect.isFalse(timerCallbackExecuted);
     }));
   });
 }

tests/lib/async/stream_controller_async_test.dart

@@ -6,7 +6,8 @@
 library stream_controller_async_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import "package:expect/expect.dart";
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 import 'stream_state_helper.dart';
 
@@ -19,7 +20,7 @@ testController() {
     Stream stream = c.stream.asBroadcastStream(onCancel: cancelSub);
     stream.fold(0, (a,b) => a + b)
      .then(expectAsync((int v) {
-        expect(42, equals(v));
+        Expect.equals(42, v);
     }));
     c.add(10);
     c.add(32);
@@ -30,7 +31,7 @@ testController() {
     StreamController c = new StreamController();
     Stream stream = c.stream.asBroadcastStream(onCancel: cancelSub);
     stream.fold(0, (a,b) { throw "Fnyf!"; })
-     .catchError(expectAsync((error) { expect("Fnyf!", equals(error)); }));
+     .catchError(expectAsync((error) { Expect.equals("Fnyf!", error); }));
     c.add(42);
   });
 }
@@ -40,7 +41,7 @@ testSingleController() {
     StreamController c = new StreamController();
     Stream stream = c.stream;
     stream.fold(0, (a,b) => a + b)
-    .then(expectAsync((int v) { expect(42, equals(v)); }));
+    .then(expectAsync((int v) { Expect.equals(42, v); }));
     c.add(10);
     c.add(32);
     c.close();
@@ -50,7 +51,7 @@ testSingleController() {
     StreamController c = new StreamController();
     Stream stream = c.stream;
     stream.fold(0, (a,b) { throw "Fnyf!"; })
-            .catchError(expectAsync((e) { expect("Fnyf!", equals(e)); }));
+            .catchError(expectAsync((e) { Expect.equals("Fnyf!", e); }));
     c.add(42);
   });
 
@@ -69,7 +70,7 @@ testSingleController() {
         counter += data;
       },
       onDone: expectAsync(() {
-        expect(3, equals(counter));
+        Expect.equals(3, counter);
       }));
   });
 }
@@ -83,7 +84,7 @@ testExtraMethods() {
     Future f = c.stream.forEach(actualEvents.add);
     f.then(expectAsync((_) {
       actualEvents.close();
-      expect(sentEvents.events, equals(actualEvents.events));
+      Expect.listEquals(sentEvents.events, actualEvents.events);
     }));
     sentEvents.replay(c);
   });
@@ -94,8 +95,8 @@ testExtraMethods() {
     Events actualEvents = new Events();
     Future f = c.stream.forEach(actualEvents.add);
     f.catchError(expectAsync((error) {
-      expect("bad", equals(error));
-      expect((new Events()..add(7)).events, equals(actualEvents.events));
+      Expect.equals("bad", error);
+      Expect.listEquals((new Events()..add(7)).events, actualEvents.events);
     }));
     sentEvents.replay(c);
   });
@@ -109,8 +110,8 @@ testExtraMethods() {
       actualEvents.add(x);
     });
     f.catchError(expectAsync((error) {
-      expect("bad", equals(error));
-      expect((new Events()..add(7)).events, equals(actualEvents.events));
+      Expect.equals("bad", error);
+      Expect.listEquals((new Events()..add(7)).events, actualEvents.events);
     }));
     sentEvents.replay(c);
   });
@@ -118,7 +119,7 @@ testExtraMethods() {
   test("firstWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.firstWhere((x) => (x % 3) == 0);
-    f.then(expectAsync((v) { expect(9, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(9, v); }));
     sentEvents.replay(c);
   });
 
@@ -132,7 +133,7 @@ testExtraMethods() {
   test("firstWhere 3", () {
     StreamController c = new StreamController();
     Future f = c.stream.firstWhere((x) => (x % 4) == 0, defaultValue: () => 999);
-    f.then(expectAsync((v) { expect(999, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(999, v); }));
     sentEvents.replay(c);
   });
 
@@ -140,7 +141,7 @@ testExtraMethods() {
   test("lastWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.lastWhere((x) => (x % 3) == 0);
-    f.then(expectAsync((v) { expect(87, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(87, v); }));
     sentEvents.replay(c);
   });
 
@@ -154,35 +155,35 @@ testExtraMethods() {
   test("lastWhere 3", () {
     StreamController c = new StreamController();
     Future f = c.stream.lastWhere((x) => (x % 4) == 0, defaultValue: () => 999);
-    f.then(expectAsync((v) { expect(999, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(999, v); }));
     sentEvents.replay(c);
   });
 
   test("singleWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.singleWhere((x) => (x % 9) == 0);
-    f.then(expectAsync((v) { expect(9, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(9, v); }));
     sentEvents.replay(c);
   });
 
   test("singleWhere 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.singleWhere((x) => (x % 3) == 0);  // Matches 9 and 87..
-    f.catchError(expectAsync((error) { expect(error is StateError, isTrue); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     sentEvents.replay(c);
   });
 
   test("first", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.then(expectAsync((v) { expect(7, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(7, v);}));
     sentEvents.replay(c);
   });
 
   test("first empty", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync((error) { expect(error is StateError, isTrue); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     Events emptyEvents = new Events()..close();
     emptyEvents.replay(c);
   });
@@ -190,7 +191,7 @@ testExtraMethods() {
   test("first error", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
@@ -198,7 +199,7 @@ testExtraMethods() {
   test("first error 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
@@ -206,14 +207,14 @@ testExtraMethods() {
   test("last", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.then(expectAsync((v) { expect(87, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(87, v);}));
     sentEvents.replay(c);
   });
 
   test("last empty", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync((error) { expect(error is StateError, isTrue); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     Events emptyEvents = new Events()..close();
     emptyEvents.replay(c);
   });
@@ -221,7 +222,7 @@ testExtraMethods() {
   test("last error", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
@@ -229,7 +230,7 @@ testExtraMethods() {
   test("last error 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
@@ -237,28 +238,28 @@ testExtraMethods() {
   test("elementAt", () {
     StreamController c = new StreamController();
     Future f = c.stream.elementAt(2);
-    f.then(expectAsync((v) { expect(13, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(13, v);}));
     sentEvents.replay(c);
   });
 
   test("elementAt 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.elementAt(20);
-    f.catchError(expectAsync((error) { expect(error is RangeError, isTrue); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is RangeError); }));
     sentEvents.replay(c);
   });
 
   test("drain", () {
     StreamController c = new StreamController();
     Future f = c.stream.drain();
-    f.then(expectAsync((v) { expect(null, equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(null, v);}));
     sentEvents.replay(c);
   });
 
   test("drain error", () {
     StreamController c = new StreamController();
     Future f = c.stream.drain();
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
@@ -365,8 +366,8 @@ testRethrow() {
     test("rethrow-$name-value", () {
       StreamController c = new StreamController();
       Stream s = streamValueTransform(c.stream, (v) { throw error; });
-      s.listen((_) { fail("unexpected value"); }, onError: expectAsync(
-          (e) { expect(error, same(e)); }));
+      s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync(
+          (e) { Expect.identical(error, e); }));
       c.add(null);
       c.close();
     });
@@ -376,8 +377,8 @@ testRethrow() {
     test("rethrow-$name-error", () {
       StreamController c = new StreamController();
       Stream s = streamErrorTransform(c.stream, (e) { throw error; });
-      s.listen((_) { fail("unexpected value"); }, onError: expectAsync(
-          (e) { expect(error, same(e)); }));
+      s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync(
+          (e) { Expect.identical(error, e); }));
       c.addError("SOME ERROR");
       c.close();
     });
@@ -387,8 +388,8 @@ testRethrow() {
     test("rethrow-$name-value", () {
       StreamController c = new StreamController();
       Future f = streamValueTransform(c.stream, (v) { throw error; });
-      f.then((v) { fail("unreachable"); },
-             onError: expectAsync((e) { expect(error, same(e)); }));
+      f.then((v) { Expect.fail("unreachable"); },
+             onError: expectAsync((e) { Expect.identical(error, e); }));
       // Need two values to trigger compare for reduce.
       c.add(0);
       c.add(1);
@@ -586,7 +587,7 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
           return sink.close();
         })
         .then((_) {
-          expect(expected.events, equals(actual.events));
+          Expect.listEquals(expected.events, actual.events);
           done();
         });
   });
@@ -611,7 +612,7 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
     sink.addError("error");
     sink.addStream(new Stream.fromIterable([1, 2, 3, 4, 5]))
         .then((_) {
-          expect(expected.events, equals(actual.events));
+          Expect.listEquals(expected.events, actual.events);
           // Close controller as well. It has no listener. If it is a broadcast
           // stream, it will still be open, and we read the "done" future before
           // closing. A normal stream is already done when its listener cancels.
@@ -621,7 +622,7 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
         })
         .then((_) {
           // No change in events.
-          expect(expected.events, equals(actual.events));
+          Expect.listEquals(expected.events, actual.events);
           done();
         });
   });
@@ -664,11 +665,11 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
             // Wait for the done event to be *delivered* before testing the
             // events.
             actual.onDone(() {
-              expect(expected.events, equals(actual.events));
+              Expect.listEquals(expected.events, actual.events);
               done();
             });
           } else {
-            expect(expected.events, equals(actual.events));
+            Expect.listEquals(expected.events, actual.events);
             done();
           }
         });
@@ -690,7 +691,7 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
     StreamController sourceController = new StreamController();
     c.addStream(sourceController.stream).then((_) {
       c.close().then((_) {
-        expect(expected.events, equals(actual.events));
+        Expect.listEquals(expected.events, actual.events);
         done();
       });
     });
@@ -714,7 +715,7 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
     StreamController sourceController = new StreamController();
     c.addStream(sourceController.stream, cancelOnError: false).then((_) {
       c.close().then((_) {
-        expect(source.events, equals(actual.events));
+        Expect.listEquals(source.events, actual.events);
         done();
       });
     });
@@ -745,7 +746,7 @@ void testSink({bool sync, bool broadcast, bool asBroadcast}) {
     c.addStream(s1).then((_) {
       c.addStream(s2, cancelOnError: false).then((_) {
         c.close().then((_) {
-          expect(expected.events, equals(actual.events));
+          Expect.listEquals(expected.events, actual.events);
           done();
         });
       });

tests/lib/async/stream_first_where_test.dart

@@ -4,8 +4,9 @@
 
 library stream_controller_async_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 import 'stream_state_helper.dart';
 
@@ -20,7 +21,7 @@ main() {
   test("firstWhere with super class", () {
     StreamController c = new StreamController<B>();
     Future f = c.stream.firstWhere((x) => false, defaultValue: () => const A());
-    f.then(expectAsync((v) { expect(const A(), equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(const A(), v); }));
     sentEvents.replay(c);
   });
 }

tests/lib/async/stream_from_iterable_test.dart

@@ -5,8 +5,9 @@
 // Test merging streams.
 library dart.test.stream_from_iterable;
 
+import "package:expect/expect.dart";
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 
 class IterableTest<T> {
@@ -19,7 +20,7 @@ class IterableTest<T> {
       Stream<T> stream = new Stream<T>.fromIterable(iterable);
       Events actual = new Events.capture(stream);
       actual.onDone(expectAsync(() {
-        expect(expected.events, equals(actual.events));
+        Expect.listEquals(expected.events, actual.events);
       }));
     });
   }
@@ -40,8 +41,8 @@ main() {
   test("iterable-toList", () {
     new Stream.fromIterable(iter).toList().then(expectAsync((actual) {
       List expected = iter.toList();
-      expect(25, equals(expected.length));
-      expect(expected, equals(actual));
+      Expect.equals(25, expected.length);
+      Expect.listEquals(expected, actual);
     }));
   });
 
@@ -51,7 +52,7 @@ main() {
       .toList()
       .then(expectAsync((actual) {
          List expected = iter.map((i) => i * 3).toList();
-         expect(expected, equals(actual));
+         Expect.listEquals(expected, actual);
       }));
   });
 
@@ -69,15 +70,15 @@ main() {
     }, onDone: expectAsync(() {
       actual.close();
       Events expected = new Events.fromIterable(iter);
-      expect(expected.events, equals(actual.events));
+      Expect.listEquals(expected.events, actual.events);
     }));
   });
 
   test("iterable-single-subscription", () {
     Stream stream = new Stream.fromIterable(iter);
     stream.listen((x){});
-    expect(() { stream.listen((x){}); },
-           throwsA(predicate((e) => e is StateError)));
+    Expect.throws(() { stream.listen((x){}); },
+                  (e) => e is StateError);
   });
 
   test("regression-14332", () {
@@ -98,7 +99,7 @@ main() {
     });
 
     c.stream.toList().then((x) {
-      expect([1,2,3,4,5], equals(x));
+      Expect.listEquals([1,2,3,4,5], x);
       done();
     });
   });
@@ -116,8 +117,8 @@ main() {
 
     var data = [], errors = [];
     c.stream.listen(data.add, onError: errors.add, onDone: () {
-      expect([1], equals(data));
-      expect([2], equals(errors));
+      Expect.listEquals([1], data);
+      Expect.listEquals([2], errors);
       done();
     });
     sink.addStream(from).then((_) {
@@ -138,8 +139,8 @@ main() {
 
     var data = [], errors = [];
     c.stream.listen(data.add, onError: errors.add, onDone: () {
-      expect([1, 3, 5], equals(data));
-      expect([2, 4], equals(errors));
+      Expect.listEquals([1, 3, 5], data);
+      Expect.listEquals([2, 4], errors);
       done();
     });
     c.addStream(from, cancelOnError: false).then((_) {

tests/lib/async/stream_iterator_test.dart

@@ -3,7 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "dart:async";
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 
 main() {
   test("stream iterator basic", () async {

tests/lib/async/stream_join_test.dart

@@ -7,7 +7,8 @@ library stream_join_test;
 
 import 'dart:async';
 import 'event_helper.dart';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
+import "package:expect/expect.dart";
 
 main() {
   test("join-empty", () {

tests/lib/async/stream_last_where_test.dart

@@ -4,8 +4,9 @@
 
 library stream_controller_async_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 import 'stream_state_helper.dart';
 
@@ -20,7 +21,7 @@ main() {
   test("lastWhere with super class", () {
     StreamController c = new StreamController<B>();
     Future f = c.stream.lastWhere((x) => false, defaultValue: () => const A());
-    f.then(expectAsync((v) { expect(const A(), equals(v)); }));
+    f.then(expectAsync((v) { Expect.equals(const A(), v); }));
     sentEvents.replay(c);
   });
 }

tests/lib/async/stream_periodic2_test.dart

@@ -6,7 +6,7 @@
 library dart.test.stream_from_iterable;
 
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("stream-periodic2", () {

tests/lib/async/stream_periodic3_test.dart

@@ -6,7 +6,7 @@
 library dart.test.stream_from_iterable;
 
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 // The stopwatch is more precise than the Timer.
 // Some browsers (Firefox and IE so far) can trigger too early. So we add more

tests/lib/async/stream_periodic4_test.dart

@@ -6,7 +6,7 @@
 library dart.test.stream_from_iterable;
 
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 void runTest(period, maxElapsed, pauseDuration) {
   Function done = expectAsync(() { });

tests/lib/async/stream_periodic5_test.dart

@@ -6,7 +6,7 @@
 library dart.test.stream_from_iterable;
 
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 watchMs(Stopwatch watch) {
   int microsecs = watch.elapsedMicroseconds;
@@ -38,7 +38,7 @@ main() {
           watch.start();
           subscription.resume();
         });
-      }
+      } 
     }, onDone: expectAsync(() { }));
   });
 }

tests/lib/async/stream_periodic6_test.dart

@@ -6,7 +6,7 @@
 library dart.test.stream_from_iterable;
 
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("stream-periodic1", () {

tests/lib/async/stream_periodic_test.dart

@@ -6,7 +6,7 @@
 library dart.test.stream_from_iterable;
 
 import "dart:async";
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("stream-periodic1", () {

tests/lib/async/stream_single_test.dart

@@ -5,29 +5,30 @@
 // Test the Stream.single method.
 library stream_single_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 
 main() {
   test("single", () {
     StreamController c = new StreamController(sync: true);
     Future f = c.stream.single;
-    f.then(expectAsync((v) { expect(42, equals(v));}));
+    f.then(expectAsync((v) { Expect.equals(42, v);}));
     new Events.fromIterable([42]).replay(c);
   });
 
   test("single empty", () {
     StreamController c = new StreamController(sync: true);
     Future f = c.stream.single;
-    f.catchError(expectAsync((error) { expect(error is StateError, isTrue); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     new Events.fromIterable([]).replay(c);
   });
 
   test("single error", () {
     StreamController c = new StreamController(sync: true);
     Future f = c.stream.single;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
@@ -35,7 +36,7 @@ main() {
   test("single error 2", () {
     StreamController c = new StreamController(sync: true);
     Future f = c.stream.single;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
@@ -43,7 +44,7 @@ main() {
   test("single error 3", () {
     StreamController c = new StreamController(sync: true);
     Future f = c.stream.single;
-    f.catchError(expectAsync((error) { expect("error", equals(error)); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..add(499)..error("error")..close();
     errorEvents.replay(c);
   });

tests/lib/async/stream_single_to_multi_subscriber_test.dart

@@ -5,8 +5,9 @@
 // Test the basic StreamController and StreamController.singleSubscription.
 library stream_single_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 
 main() {
@@ -14,8 +15,8 @@ main() {
     StreamController c = new StreamController<int>(sync: true);
     Stream<int> multi = c.stream.asBroadcastStream();
     // Listen twice.
-    multi.listen(expectAsync((v) => expect(42, equals(v))));
-    multi.listen(expectAsync((v) => expect(42, equals(v))));
+    multi.listen(expectAsync((v) => Expect.equals(42, v)));
+    multi.listen(expectAsync((v) => Expect.equals(42, v)));
     c.add(42);
   });
 
@@ -26,10 +27,10 @@ main() {
     Events actual1 = new Events.capture(multi);
     Events actual2 = new Events.capture(multi);
     actual1.onDone(expectAsync(() {
-      expect(expected.events, equals(actual1.events));
+      Expect.listEquals(expected.events, actual1.events);
     }));
     actual2.onDone(expectAsync(() {
-      expect(expected.events, equals(actual2.events));
+      Expect.listEquals(expected.events, actual2.events);
     }));
     expected.replay(c);
   });
@@ -41,10 +42,10 @@ main() {
     Events actual1 = new Events.capture(multi);
     Events actual2 = new Events.capture(multi);
     actual1.onDone(expectAsync(() {
-      expect(expected.events, equals(actual1.events));
+      Expect.listEquals(expected.events, actual1.events);
     }));
     actual2.onDone(expectAsync(() {
-      expect(expected.events, equals(actual2.events));
+      Expect.listEquals(expected.events, actual2.events);
     }));
     expected.replay(c);
   });

tests/lib/async/stream_state_helper.dart

@@ -4,7 +4,7 @@
 
 library stream_state_helper;
 
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 import "dart:async";
 import "dart:collection";
 

tests/lib/async/stream_state_nonzero_timer_test.dart

@@ -8,7 +8,7 @@
 library stream_state_nonzero_timer_test;
 
 import "dart:async";
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 import "stream_state_helper.dart";
 
 const ms5 = const Duration(milliseconds: 5);

tests/lib/async/stream_state_test.dart

@@ -5,7 +5,7 @@
 // Test the event/callback protocol of the stream implementations.
 library stream_state_test;
 
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 import "stream_state_helper.dart";
 
 const ms5 = const Duration(milliseconds: 5);

tests/lib/async/stream_subscription_as_future_test.dart

@@ -5,8 +5,9 @@
 // Test the Stream.single method.
 library stream_single_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test("subscription.asFuture success", () {
@@ -14,7 +15,7 @@ main() {
     var output = [];
     var subscription = stream.listen((x) { output.add(x); });
     subscription.asFuture(output).then(expectAsync((o) {
-      expect([1, 2, 3], equals(o));
+      Expect.listEquals([1, 2, 3], o);
     }));
   });
 
@@ -26,7 +27,7 @@ main() {
     var output = [];
     var subscription = stream.listen((x) { output.add(x); });
     subscription.asFuture(output).then(expectAsync((o) {
-      expect([1, 2, 3], equals(o));
+      Expect.listEquals([1, 2, 3], o);
     }));
   });
 
@@ -35,7 +36,7 @@ main() {
     var output = [];
     var subscription = stream.listen((x) { output.add(x); });
     subscription.asFuture(output).then(expectAsync((o) {
-      expect([1, 2, 3], equals(o));
+      Expect.listEquals([1, 2, 3], o);
     }));
   });
 
@@ -45,8 +46,8 @@ main() {
     var output = [];
     var subscription = stream.listen((x) { output.add(x); });
     subscription.asFuture("string").then((String o) {
-      expect([1, 2, 3], equals(output));
-      expect("string", equals(o));
+      Expect.listEquals([1, 2, 3], output);
+      Expect.equals("string", o);
       asyncCallback();
     });
   });
@@ -60,7 +61,7 @@ main() {
     var output = [];
     var subscription = stream.listen((x) { output.add(x); });
     subscription.asFuture(output).catchError(expectAsync((error) {
-      expect(error, equals("foo"));
+      Expect.equals(error, "foo");
     }));
   });
 
@@ -73,7 +74,7 @@ main() {
     var output = [];
     var subscription = stream.listen((x) { output.add(x); });
     subscription.asFuture(output).catchError(expectAsync((error) {
-      expect(error, equals("foo"));
+      Expect.equals(error, "foo");
     }));
   });
 
@@ -89,11 +90,11 @@ main() {
     var subscription = stream.listen((x) { output.add(x); });
     bool catchErrorHasRun = false;
     subscription.asFuture(output).catchError(expectAsync((error) {
-      expect(error, equals("foo"));
+      Expect.equals(error, "foo");
       catchErrorHasRun = true;
     }));
     Timer.run(expectAsync(() {
-      expect(catchErrorHasRun, isFalse);
+      Expect.isFalse(catchErrorHasRun);
       completer.complete();
     }));
   });
@@ -111,15 +112,15 @@ main() {
       var subscription = stream.listen((x) { output.add(x); });
       bool catchErrorHasRun = false;
       subscription.asFuture(output).catchError(expectAsync((error) {
-        expect(error, equals("foo"));
+        Expect.equals(error, "foo");
         catchErrorHasRun = true;
       }));
       Timer.run(expectAsync(() {
-        expect(catchErrorHasRun, isFalse);
+        Expect.isFalse(catchErrorHasRun);
         completer.completeError(499);
       }));
     }, onError: expectAsync((e) {
-      expect(499, equals(e));
+      Expect.equals(499, e);
     }));
   });
 }

tests/lib/async/stream_subscription_cancel_test.dart

@@ -6,7 +6,7 @@
 library stream_subscription_cancel;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 void main() {
   test('subscription.cancel', () {

tests/lib/async/stream_transform_test.dart

@@ -4,8 +4,9 @@
 
 library stream_transform_test;
 
+import "package:expect/expect.dart";
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'event_helper.dart';
 
 
@@ -27,7 +28,7 @@ main() {
     Events actual = new Events.capture(
         c.stream.map((x) => x * 2).where((x) => x > 5).skip(2).take(2));
     actual.onDone(expectAsync(() {
-      expect(expected.events, equals(actual.events));
+      Expect.listEquals(expected.events, actual.events);
     }));
     input.replay(c);
   });
@@ -39,7 +40,7 @@ main() {
     Events actual = new Events.capture(
         c.stream.map((x) => x * 2).where((x) => x > 5).skip(2).take(2));
     actual.onDone(expectAsync(() {
-      expect(expected.events, equals(actual.events));
+      Expect.listEquals(expected.events, actual.events);
     }));
     actual.pause();
     input.replay(c);

tests/lib/async/stream_transformation_broadcast_test.dart

@@ -7,7 +7,8 @@ library stream_join_test;
 
 import 'dart:async';
 import 'event_helper.dart';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
+import "package:expect/expect.dart";
 
 main() {
   testStream("singlesub", () => new StreamController(), (c) => c.stream);
@@ -26,9 +27,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.map((x) => x + 1);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(43, equals(v));
+      Expect.equals(43, v);
     }));
     c.add(42);
     c.close();
@@ -37,9 +38,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.where((x) => x.isEven);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(37);
     c.add(42);
@@ -50,9 +51,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.handleError((x, s) {});
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.addError("BAD1");
     c.add(42);
@@ -63,9 +64,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.expand((x) => x.isEven ? [x] : []);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(37);
     c.add(42);
@@ -80,9 +81,9 @@ void testStream(String name,
         handleData: (value, EventSink sink) { sink.add(value); }
     );
     Stream newStream = s.transform(t);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(42);
     c.close();
@@ -91,9 +92,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.take(1);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(42);
     c.add(37);
@@ -103,9 +104,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.takeWhile((x) => x.isEven);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(42);
     c.add(37);
@@ -115,9 +116,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.skip(1);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(37);
     c.add(42);
@@ -127,9 +128,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.skipWhile((x) => x.isOdd);
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(37);
     c.add(42);
@@ -139,9 +140,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.distinct();
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(42);
     c.add(42);
@@ -151,9 +152,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.timeout(const Duration(seconds: 1));
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(42, equals(v));
+      Expect.equals(42, v);
     }));
     c.add(42);
     c.close();
@@ -162,9 +163,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.asyncMap((x) => new Future.value(x + 1));
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(43, equals(v));
+      Expect.equals(43, v);
     }));
     c.add(42);
     c.close();
@@ -173,9 +174,9 @@ void testStream(String name,
     var c = create();
     var s = getStream(c);
     Stream newStream = s.asyncExpand((x) => new Stream.fromIterable([x + 1]));
-    expect(s.isBroadcast, equals(newStream.isBroadcast));
+    Expect.equals(s.isBroadcast, newStream.isBroadcast);
     newStream.single.then(expectAsync((v) {
-      expect(43, equals(v));
+      Expect.equals(43, v);
     }));
     c.add(42);
     c.close();
@@ -321,7 +322,7 @@ void testStream(String name,
     // Listen immediately, to ensure that an asBroadcast stream is started.
     var sub = newStream.listen((_){});
     int i = 0;
-    // Non-overlapping ranges means the test must not remember its first
+    // Non-overlapping ranges means the test must not remember its first 
     // failure.
     var expect1 = 6;
     var expect2 = 16;

tests/lib/async/timer_cancel1_test.dart

@@ -4,7 +4,7 @@
 
 library timer_cancel1_test;
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   // Test that a timeout handler can cancel another.

tests/lib/async/timer_cancel2_test.dart

@@ -5,7 +5,7 @@
 library timer_cancel2_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   // Test that a timeout handler can cancel itself.

tests/lib/async/timer_cancel_test.dart

@@ -5,7 +5,7 @@
 library timer_cancel_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   final ms = const Duration(milliseconds: 1);

tests/lib/async/timer_isActive_test.dart

@@ -3,7 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
 

tests/lib/async/timer_repeat_test.dart

@@ -5,7 +5,7 @@
 library timer_repeat_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 const Duration TIMEOUT = const Duration(milliseconds: 500);
 const int ITERATIONS = 5;

tests/lib/async/timer_test.dart

@@ -5,7 +5,7 @@
 library timer_test;
 
 import 'dart:async';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 const int STARTTIMEOUT = 1050;
 const int DECREASE = 200;

tests/lib/convert/json_lib_test.dart

@@ -3,7 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 library json_tests;
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 import 'dart:convert';
 
 main() {

tests/lib/math/point_test.dart

@@ -5,7 +5,7 @@
 library point_test;
 
 import 'dart:math';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   test('constructor', () {

tests/lib/math/rectangle_test.dart

@@ -5,7 +5,7 @@
 library rect_test;
 
 import 'dart:math';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 main() {
   Rectangle createRectangle(List<num> a) {

tests/lib/mirrors/library_uri_io_test.dart

@@ -8,7 +8,7 @@ library MirrorsTest;
 
 import 'dart:mirrors';
 import 'dart:io';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 class Class {
 }

tests/lib/mirrors/library_uri_package_test.dart

@@ -8,7 +8,7 @@ library MirrorsTest;
 
 import 'dart:mirrors';
 import 'package:args/args.dart';
-import 'package:test/test.dart';
+import 'package:unittest/unittest.dart';
 
 testLibraryUri(var value, Uri expectedUri) {
   var valueMirror = reflect(value);

tests/standalone/io/sleep_test.dart

@@ -3,9 +3,9 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import "dart:io";
-import "package:test/test.dart";
+import "package:unittest/unittest.dart";
 
-sleepTest(int milliseconds) {
+test(int milliseconds) {
   var watch = new Stopwatch();
   watch.start();
   sleep(new Duration(milliseconds: milliseconds));
@@ -14,26 +14,16 @@ sleepTest(int milliseconds) {
 }
 
 main() {
-  test("zero", () {
-    sleepTest(0);
-  });
-  test("one", () {
-    sleepTest(1);
-  });
-  test("ten", () {
-    sleepTest(10);
-  });
-  test("100", () {
-    sleepTest(100);
-  });
-  test("error", () {
-    bool sawError = false;
-    try {
-      sleep(new Duration(milliseconds: -1));
-      expect(false, isTrue);  // should not reach here.
-    } on ArgumentError catch(e) {
-      sawError = true;
-    }
-    expect(sawError, isTrue);
-  });
+  test(0);
+  test(1);
+  test(10);
+  test(100);
+  bool sawError = false;
+  try {
+    sleep(new Duration(milliseconds: -1));
+    expect(false, isTrue);  // should not reach here.
+  } on ArgumentError catch(e) {
+    sawError = true;
+  }
+  expect(sawError, isTrue);
 }