Renamed StreamSink to EventSink. Renamed signalError to addError.

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 200 matching lines @@
       expect(stream.elementAt(1), completion(equals(2)));
       expect(errorGroup.done, completes);
 
       controller..add(1)..add(2)..close();
     });
 
     test('should pass through an error from the stream if it has a '
         'listener', () {
       expect(stream.first, throwsFormatException);
       // errorGroup shouldn't top-level the exception
-      controller.signalError(new AsyncError(new FormatException()));
+      controller.addError(new AsyncError(new FormatException()));
     });
 
     test('should notify the error group of an exception from the stream even '
         'if it has a listener', () {
       expect(stream.first, throwsFormatException);
       expect(errorGroup.done, throwsFormatException);
-      controller.signalError(new AsyncError(new FormatException()));
+      controller.addError(new AsyncError(new FormatException()));
     });
 
     test('should pass a signaled exception to the stream if it has a listener '
         'and should unsubscribe that stream', () {
       expect(stream.first, throwsFormatException);
       // errorGroup shouldn't top-level the exception
       errorGroup.signalError(new AsyncError(new FormatException()));
 
       expect(stream.first.catchError((_) {
         controller.add('value');
@@ skipping 16 matching lines @@
 
       // A listener added afterwards should see an empty stream, since it's not
       // single-subscription
       expect(errorGroup.done.then((_) => stream.toList()),
           completion(isEmpty));
     });
 
     test("should pipe an exception from the stream to .done if the stream "
         "doesn't have a listener", () {
       expect(errorGroup.done, throwsFormatException);
-      controller.signalError(new AsyncError(new FormatException()));
+      controller.addError(new AsyncError(new FormatException()));
 
       // A listener added afterwards should see an empty stream, since it's not
       // single-subscription
       expect(errorGroup.done.catchError((_) {
         controller.add('value'); // should be ignored
         return stream.toList();
       }), completion(isEmpty));
     });
 
     test("should pass a signaled exception to .done if the stream doesn't "
@@ skipping 27 matching lines @@
       controller.close();
 
       // A listener added afterwards should receive the value
       expect(errorGroup.done.then((_) => stream.toList()),
           completion(equals(['value'])));
     });
 
     test("should pipe an exception from the stream to .done if the stream "
         "doesn't have a listener", () {
       expect(errorGroup.done, throwsFormatException);
-      controller.signalError(new AsyncError(new FormatException()));
+      controller.addError(new AsyncError(new FormatException()));
 
       // A listener added afterwards should receive the exception
       expect(errorGroup.done.catchError((_) {
         controller.add('value'); // should be ignored
         expect(stream.first, throwsFormatException);
       }), completes);
     });
 
     test("should pass a signaled exception to .done if the stream doesn't "
         "have a listener",
@@ skipping 22 matching lines @@
       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()));
+      controller1.addError(new AsyncError(new FormatException()));
     });
 
     test("each future should be able to emit values independently", () {
       expect(stream1.toList(), completion(equals(['value1.1', 'value1.2'])));
       expect(stream2.toList(), completion(equals(['value2.1', 'value2.2'])));
       expect(errorGroup.done, completes);
 
       controller1..add('value1.1')..add('value1.2')..close();
       controller2..add('value2.1')..add('value2.2')..close();
     });
 
     test("shouldn't throw a top-level exception if a stream receives an error "
         "after the other listened stream completes", () {
       expect(stream1.toList(), completion(equals(['value1', 'value2'])));
       controller1..add('value1')..add('value2')..close();
 
       expect(stream1.toList().then((_) {
         // shouldn't cause a top-level exception
-        controller2.signalError(new AsyncError(new FormatException()));
+        controller2.addError(new AsyncError(new FormatException()));
       }), completes);
     });
 
     test("shouldn't throw a top-level exception if an error is signaled after "
         "one listened stream completes", () {
       expect(stream1.toList(), completion(equals(['value1', 'value2'])));
       controller1..add('value1')..add('value2')..close();
 
       expect(stream1.toList().then((_) {
         // shouldn't cause a top-level exception
@@ skipping 14 matching lines @@
       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()));
+      controller.addError(new AsyncError(new FormatException()));
     });
 
     test("should pipe exceptions from the future to the stream", () {
       expect(stream.first, throwsFormatException);
       expect(future, throwsFormatException);
       expect(errorGroup.done, throwsFormatException);
 
       completer.completeError(new FormatException());
     });
 
     test("the stream and the future should be able to complete/emit values "
         "independently", () {
       expect(stream.toList(), completion(equals(['value1.1', 'value1.2'])));
       expect(future, completion(equals('value2.0')));
       expect(errorGroup.done, completes);
 
       controller..add('value1.1')..add('value1.2')..close();
       completer.complete('value2.0');
     });
 
     test("shouldn't throw a top-level exception if the stream receives an error "
         "after the listened future completes", () {
       expect(future, completion(equals('value')));
       completer.complete('value');
 
       expect(future.then((_) {
         // shouldn't cause a top-level exception
-        controller.signalError(new AsyncError(new FormatException()));
+        controller.addError(new AsyncError(new FormatException()));
       }), completes);
     });
 
     test("shouldn't throw a top-level exception if the future receives an "
         "error after the listened stream completes", () {
       expect(stream.toList(), completion(equals(['value1', 'value2'])));
       controller..add('value1')..add('value2')..close();
 
       expect(stream.toList().then((_) {
         // shouldn't cause a top-level exception
         completer.completeError(new FormatException());
       }), completes);
     });
   });
 }