Stop treating StreamController as a Stream.

utils/tests/pub/error_group_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.
 
 library error_group_test;
 
 import 'dart:async';
 
 import '../../../pkg/unittest/lib/unittest.dart';
 import '../../pub/error_group.dart';
@@ skipping 19 matching lines @@
       errorGroup.signalError(new AsyncError(new FormatException()));
     });
 
     test("shouldn't allow additional futures or streams once an error has been "
         "signaled", () {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new AsyncError(new FormatException()));
 
       expect(() => errorGroup.registerFuture(new Future.immediate(null)),
           throwsStateError);
-      expect(() => errorGroup.registerStream(new StreamController()),
+      expect(() => errorGroup.registerStream(new StreamController().stream),
           throwsStateError);
     });
   });
 
   group('with a single future', () {
     Completer completer;
     Future future;
 
     setUp(() {
       errorGroup = new ErrorGroup();
       completer = new Completer();
       future = errorGroup.registerFuture(completer.future);
     });
 
     test('should pass through a value from the future', () {
       expect(future, completion(equals('value')));
       expect(errorGroup.done, completes);
       completer.complete('value');
     });
 
     test("shouldn't allow additional futures or streams once .done has "
         "been called", () {
       completer.complete('value');
 
       expect(() => errorGroup.registerFuture(new Future.immediate(null)),
           throwsStateError);
-      expect(() => errorGroup.registerStream(new StreamController()),
+      expect(() => errorGroup.registerStream(new StreamController().stream),
           throwsStateError);
     });
 
     test('should pass through an exception from the future if it has a '
         'listener', () {
       expect(future, throwsFormatException);
       // errorGroup shouldn't top-level the exception
       completer.completeError(new FormatException());
     });
 
@@ skipping 118 matching lines @@
     });
   });
 
   group('with a single stream', () {
     StreamController controller;
     Stream stream;
 
     setUp(() {
       errorGroup = new ErrorGroup();
       controller = new StreamController.multiSubscription();
-      stream = errorGroup.registerStream(controller);
+      stream = errorGroup.registerStream(controller.stream);
     });
 
     test('should pass through values from the stream', () {
       expect(stream.elementAt(0), completion(equals(1)));
       expect(stream.elementAt(1), completion(equals(2)));
       expect(errorGroup.done, completes);
 
       controller..add(1)..add(2)..close();
     });
 
@@ skipping 69 matching lines @@
     });
   });
 
   group('with a single single-subscription stream', () {
     StreamController controller;
     Stream stream;
 
     setUp(() {
       errorGroup = new ErrorGroup();
       controller = new StreamController();
-      stream = errorGroup.registerStream(controller);
+      stream = errorGroup.registerStream(controller.stream);
     });
 
     test("should complete .done when the stream is done even if the stream "
         "doesn't have a listener", () {
       expect(errorGroup.done, completes);
       controller.add('value');
       controller.close();
 
       // A listener added afterwards should receive the value
       expect(errorGroup.done.then((_) => stream.toList()),
@@ skipping 29 matching lines @@
   group('with multiple streams', () {
     StreamController controller1;
     StreamController controller2;
     Stream stream1;
     Stream stream2;
 
     setUp(() {
       errorGroup = new ErrorGroup();
       controller1 = new StreamController.multiSubscription();
       controller2 = new StreamController.multiSubscription();
-      stream1 = errorGroup.registerStream(controller1);
-      stream2 = errorGroup.registerStream(controller2);
+      stream1 = errorGroup.registerStream(controller1.stream);
+      stream2 = errorGroup.registerStream(controller2.stream);
     });
 
     test("should pipe exceptions from one stream to the other and to .done",
         () {
       expect(stream1.first, throwsFormatException);
       expect(stream2.first, throwsFormatException);
       expect(errorGroup.done, throwsFormatException);
 
       controller1.signalError(new AsyncError(new FormatException()));
     });
@@ skipping 32 matching lines @@
 
   group('with a stream and a future', () {
     StreamController controller;
     Stream stream;
     Completer completer;
     Future future;
 
     setUp(() {
       errorGroup = new ErrorGroup();
       controller = new StreamController.multiSubscription();
-      stream = errorGroup.registerStream(controller);
+      stream = errorGroup.registerStream(controller.stream);
       completer = new Completer();
       future = errorGroup.registerFuture(completer.future);
     });
 
     test("should pipe exceptions from the stream to the future", () {
       expect(stream.first, throwsFormatException);
       expect(future, throwsFormatException);
       expect(errorGroup.done, throwsFormatException);
 
       controller.signalError(new AsyncError(new FormatException()));
@@ skipping 46 matching lines @@
 const isStateError = const _StateError();
 
 /// A matcher for functions that throw StateError.
 const Matcher throwsStateError =
     const Throws(isStateError);
 
 class _StateError extends TypeMatcher {
   const _StateError() : super("StateError");
   bool matches(item, MatchState matchState) => item is StateError;
 }