Remove package:unittest from some tests

tests/lib/async/stream_transformation_broadcast_test.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.
 
 // Test that transformations like `map` and `where` preserve broadcast flag.
 library stream_join_test;
 
 import 'dart:async';
 import 'event_helper.dart';
-import 'package:unittest/unittest.dart';
-import "package:expect/expect.dart";
+import 'package:test/test.dart';
 
 main() {
   testStream("singlesub", () => new StreamController(), (c) => c.stream);
   testStream("broadcast", () => new StreamController.broadcast(),
                           (c) => c.stream);
   testStream("asBroadcast", () => new StreamController(),
                             (c) => c.stream.asBroadcastStream());
   testStream("broadcast.asBroadcast", () => new StreamController.broadcast(),
                                       (c) => c.stream.asBroadcastStream());
 }
 
 void testStream(String name,
                 StreamController create(),
                 Stream getStream(controller)) {
   test("$name-map", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.map((x) => x + 1);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(43, v);
+      expect(43, equals(v));
     }));
     c.add(42);
     c.close();
   });
   test("$name-where", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.where((x) => x.isEven);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(37);
     c.add(42);
     c.add(87);
     c.close();
   });
   test("$name-handleError", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.handleError((x, s) {});
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.addError("BAD1");
     c.add(42);
     c.addError("BAD2");
     c.close();
   });
   test("$name-expand", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.expand((x) => x.isEven ? [x] : []);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(37);
     c.add(42);
     c.add(87);
     c.close();
   });
   test("$name-transform", () {
     var c = create();
     var s = getStream(c);
     // TODO: find name of default transformer
     var t = new StreamTransformer.fromHandlers(
         handleData: (value, EventSink sink) { sink.add(value); }
     );
     Stream newStream = s.transform(t);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(42);
     c.close();
   });
   test("$name-take", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.take(1);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(42);
     c.add(37);
     c.close();
   });
   test("$name-takeWhile", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.takeWhile((x) => x.isEven);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(42);
     c.add(37);
     c.close();
   });
   test("$name-skip", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.skip(1);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(37);
     c.add(42);
     c.close();
   });
   test("$name-skipWhile", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.skipWhile((x) => x.isOdd);
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(37);
     c.add(42);
     c.close();
   });
   test("$name-distinct", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.distinct();
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(42);
     c.add(42);
     c.close();
   });
   test("$name-timeout", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.timeout(const Duration(seconds: 1));
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(42, v);
+      expect(42, equals(v));
     }));
     c.add(42);
     c.close();
   });
   test("$name-asyncMap", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.asyncMap((x) => new Future.value(x + 1));
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(43, v);
+      expect(43, equals(v));
     }));
     c.add(42);
     c.close();
   });
   test("$name-asyncExpand", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.asyncExpand((x) => new Stream.fromIterable([x + 1]));
-    Expect.equals(s.isBroadcast, newStream.isBroadcast);
+    expect(s.isBroadcast, equals(newStream.isBroadcast));
     newStream.single.then(expectAsync((v) {
-      Expect.equals(43, v);
+      expect(43, equals(v));
     }));
     c.add(42);
     c.close();
   });
 
   // The following tests are only on broadcast streams, they require listening
   // more than once.
   if (name.startsWith("singlesub")) return;
 
   test("$name-skip-multilisten", () {
@@ skipping 125 matching lines @@
     scheduleMicrotask(loop);
   });
 
   test("$name-takeWhile-multilisten", () {
     var c = create();
     var s = getStream(c);
     Stream newStream = s.takeWhile((x) => (x % 10) != 5);
     // 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;
     var handler2 = expectAsync((v) {
       expect(v, expect2);
       expect(v <= 25, isTrue);
       expect2++;
     }, count: 9);
     var handler1 = expectAsync((v) {
       expect(v, expect1);
@@ skipping 17 matching lines @@
       if (i < 25) {
         scheduleMicrotask(loop);
       } else {
         sub.cancel();
         c.close();
       }
     }, count: 25);
     scheduleMicrotask(loop);
   });
 }