Regenerate pub sources.

sdk/lib/_internal/pub_generated/test/error_group_test.dart

Index: sdk/lib/_internal/pub_generated/test/error_group_test.dart
diff --git a/sdk/lib/_internal/pub_generated/test/error_group_test.dart b/sdk/lib/_internal/pub_generated/test/error_group_test.dart
index 23680b82fd7287d94588ef8a9ce6e51daa68f5a6..3589b3eb5495f1a769f79b1966057a15656a66db 100644
--- a/sdk/lib/_internal/pub_generated/test/error_group_test.dart
+++ b/sdk/lib/_internal/pub_generated/test/error_group_test.dart
@@ -1,24 +1,43 @@
+// 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 'package:unittest/unittest.dart';
+
 import '../lib/src/error_group.dart';
 import '../lib/src/utils.dart';
+
 ErrorGroup errorGroup;
+
+// TODO(nweiz): once there's a global error handler, we should test that it does
+// and does not get called at appropriate times. See issue 5958.
+//
+// One particular thing we should test that has no tests now is that a stream
+// that has a subscription added and subsequently canceled counts as having no
+// listeners.
+
 main() {
   group('with no futures or streams', () {
     setUp(() {
       errorGroup = new ErrorGroup();
     });
+
     test('should pass signaled errors to .done', () {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new FormatException());
     });
+
     test(
         "shouldn't allow additional futures or streams once an error has been "
             "signaled",
         () {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new FormatException());
+
       expect(
           () => errorGroup.registerFuture(new Future.value()),
           throwsStateError);
@@ -27,23 +46,28 @@ main() {
           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(
           completer.future.then((_) => errorGroup.registerFuture(new Future.value())),
           throwsStateError);
@@ -52,12 +76,15 @@ main() {
               (_) => errorGroup.registerStream(new StreamController(sync: true).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());
     });
+
     test(
         'should notify the error group of an exception from the future even '
             'if it has a listener',
@@ -66,22 +93,27 @@ main() {
       expect(errorGroup.done, throwsFormatException);
       completer.completeError(new FormatException());
     });
+
     test(
         'should pass a signaled exception to the future if it has a listener '
             'and should ignore a subsequent value from that future',
         () {
       expect(future, throwsFormatException);
+      // errorGroup shouldn't top-level the exception
       errorGroup.signalError(new FormatException());
       completer.complete('value');
     });
+
     test(
         'should pass a signaled exception to the future if it has a listener '
             'and should ignore a subsequent exception from that future',
         () {
       expect(future, throwsFormatException);
+      // errorGroup shouldn't top-level the exception
       errorGroup.signalError(new FormatException());
       completer.completeError(new ArgumentError());
     });
+
     test(
         'should notify the error group of a signaled exception even if the '
             'future has a listener',
@@ -90,41 +122,52 @@ main() {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new FormatException());
     });
+
     test(
         "should complete .done if the future receives a value even if the "
             "future doesn't have a listener",
         () {
       expect(errorGroup.done, completes);
       completer.complete('value');
+
+      // A listener added afterwards should receive the value
       expect(errorGroup.done.then((_) => future), completion(equals('value')));
     });
+
     test(
         "should pipe an exception from the future to .done if the future "
             "doesn't have a listener",
         () {
       expect(errorGroup.done, throwsFormatException);
       completer.completeError(new FormatException());
+
+      // A listener added afterwards should receive the exception
       expect(errorGroup.done.catchError((_) {
         expect(future, throwsFormatException);
       }), completes);
     });
+
     test(
         "should pass a signaled exception to .done if the future doesn't have "
             "a listener",
         () {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new FormatException());
+
+      // A listener added afterwards should receive the exception
       expect(errorGroup.done.catchError((_) {
-        completer.complete('value');
+        completer.complete('value'); // should be ignored
         expect(future, throwsFormatException);
       }), completes);
     });
   });
+
   group('with multiple futures', () {
     Completer completer1;
     Completer completer2;
     Future future1;
     Future future2;
+
     setUp(() {
       errorGroup = new ErrorGroup();
       completer1 = new Completer();
@@ -132,52 +175,65 @@ main() {
       future1 = errorGroup.registerFuture(completer1.future);
       future2 = errorGroup.registerFuture(completer2.future);
     });
+
     test(
         "should pipe exceptions from one future to the other and to " ".complete",
         () {
       expect(future1, throwsFormatException);
       expect(future2, throwsFormatException);
       expect(errorGroup.done, throwsFormatException);
+
       completer1.completeError(new FormatException());
     });
+
     test(
         "each future should be able to complete with a value " "independently",
         () {
       expect(future1, completion(equals('value1')));
       expect(future2, completion(equals('value2')));
       expect(errorGroup.done, completes);
+
       completer1.complete('value1');
       completer2.complete('value2');
     });
+
     test(
         "shouldn't throw a top-level exception if a future receives an error "
             "after the other listened future completes",
         () {
       expect(future1, completion(equals('value')));
       completer1.complete('value');
+
       expect(future1.then((_) {
+        // shouldn't cause a top-level exception
         completer2.completeError(new FormatException());
       }), completes);
     });
+
     test(
         "shouldn't throw a top-level exception if an error is signaled after "
             "one listened future completes",
         () {
       expect(future1, completion(equals('value')));
       completer1.complete('value');
+
       expect(future1.then((_) {
+        // shouldn't cause a top-level exception
         errorGroup.signalError(new FormatException());
       }), completes);
     });
   });
+
   group('with a single stream', () {
     StreamController controller;
     Stream stream;
+
     setUp(() {
       errorGroup = new ErrorGroup();
       controller = new StreamController.broadcast(sync: true);
       stream = errorGroup.registerStream(controller.stream);
     });
+
     test('should pass through values from the stream', () {
       StreamIterator iter = new StreamIterator(stream);
       iter.moveNext().then((hasNext) {
@@ -190,17 +246,21 @@ main() {
         });
       });
       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.addError(new FormatException());
     });
+
     test(
         'should notify the error group of an exception from the stream even '
             'if it has a listener',
@@ -209,16 +269,20 @@ main() {
       expect(errorGroup.done, throwsFormatException);
       controller.addError(new FormatException());
     });
+
     test(
         'should pass a signaled exception to the stream if it has a listener '
             'and should unsubscribe that stream',
         () {
+      // errorGroup shouldn't top-level the exception
       expect(stream.first, throwsFormatException);
       errorGroup.signalError(new FormatException());
+
       expect(newFuture(() {
         controller.add('value');
       }), completes);
     });
+
     test(
         'should notify the error group of a signaled exception even if the '
             'stream has a listener',
@@ -227,6 +291,7 @@ main() {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new FormatException());
     });
+
     test(
         "should see one value and complete .done when the stream is done even "
             "if the stream doesn't have a listener",
@@ -234,19 +299,26 @@ main() {
       expect(errorGroup.done, completes);
       controller.add('value');
       controller.close();
+
+      // Now that broadcast controllers have been removed a listener should
+      // see the value that has been put into the controller.
       expect(
           errorGroup.done.then((_) => stream.toList()),
           completion(equals(['value'])));
     });
+
   });
+
   group('with a single single-subscription stream', () {
     StreamController controller;
     Stream stream;
+
     setUp(() {
       errorGroup = new ErrorGroup();
       controller = new StreamController(sync: true);
       stream = errorGroup.registerStream(controller.stream);
     });
+
     test(
         "should complete .done when the stream is done even if the stream "
             "doesn't have a listener",
@@ -254,38 +326,48 @@ main() {
       expect(errorGroup.done, completes);
       controller.add('value');
       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.addError(new FormatException());
+
+      // A listener added afterwards should receive the exception
       expect(errorGroup.done.catchError((_) {
-        controller.add('value');
+        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",
         () {
       expect(errorGroup.done, throwsFormatException);
       errorGroup.signalError(new FormatException());
+
+      // A listener added afterwards should receive the exception
       expect(errorGroup.done.catchError((_) {
-        controller.add('value');
+        controller.add('value'); // should be ignored
         expect(stream.first, throwsFormatException);
       }), completes);
     });
   });
+
   group('with multiple streams', () {
     StreamController controller1;
     StreamController controller2;
     Stream stream1;
     Stream stream2;
+
     setUp(() {
       errorGroup = new ErrorGroup();
       controller1 = new StreamController.broadcast(sync: true);
@@ -293,18 +375,22 @@ main() {
       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.addError(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')
@@ -314,6 +400,7 @@ main() {
           ..add('value2.2')
           ..close();
     });
+
     test(
         "shouldn't throw a top-level exception if a stream receives an error "
             "after the other listened stream completes",
@@ -326,10 +413,13 @@ main() {
           ..add('value1')
           ..add('value2')
           ..close();
+
       expect(signal.future.then((_) {
+        // shouldn't cause a top-level exception
         controller2.addError(new FormatException());
       }), completes);
     });
+
     test(
         "shouldn't throw a top-level exception if an error is signaled after "
             "one listened stream completes",
@@ -342,16 +432,20 @@ main() {
           ..add('value1')
           ..add('value2')
           ..close();
+
       expect(signal.future.then((_) {
+        // shouldn't cause a top-level exception
         errorGroup.signalError(new FormatException());
       }), completes);
     });
   });
+
   group('with a stream and a future', () {
     StreamController controller;
     Stream stream;
     Completer completer;
     Future future;
+
     setUp(() {
       errorGroup = new ErrorGroup();
       controller = new StreamController.broadcast(sync: true);
@@ -359,18 +453,23 @@ main() {
       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.addError(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",
@@ -378,22 +477,27 @@ main() {
       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.addError(new FormatException());
       }), completes);
     });
+
     test(
         "shouldn't throw a top-level exception if the future receives an "
             "error after the listened stream completes",
@@ -406,7 +510,9 @@ main() {
           ..add('value1')
           ..add('value2')
           ..close();
+
       expect(signal.future.then((_) {
+        // shouldn't cause a top-level exception
         completer.completeError(new FormatException());
       }), completes);
     });