Add setters for callbacks on StreamController.

tests/lib/async/stream_controller_test.dart

 // Copyright (c) 2011, 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 the basic StreamController and StreamController.singleSubscription.
 library stream_controller_test;
 
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 import 'dart:async';
@@ skipping 701 matching lines @@
         });
         asyncEnd();
       });
     }
     c.add(42);
     c.addError(87);
   }
   asyncEnd();
 }
 
+void testSettingCallbacks() {
+  const int initial = 0;
+  const int running = 1;
+  const int paused  = 2;
+  const int canceled = 3;
+
+  var controller = new StreamController();
+  var stream = controller.stream;
+  var state = initial;
+
+  controller..onListen = () { state = running; }
+            ..onPause  = () { state = paused; }
+            ..onResume = () { state = running; }
+            ..onCancel = () { state = canceled; };
+
+  Expect.equals(initial, state);
+  var sub = stream.listen(null);
+  Expect.equals(running, state);
+  sub.pause();
+  Expect.equals(paused, state);
+  Expect.isTrue(controller.isPaused);
+  sub.resume();
+  Expect.equals(running, state);
+  Expect.isFalse(controller.isPaused);
+
+  // Changing them later does make a difference.
+  controller..onListen = () { throw "Second listen?"; }
+            ..onPause  = () { state = -paused; }
+            ..onResume = () { state = -running; }
+            ..onCancel = () { state = -canceled; };
+
+  Expect.equals(running, state);
+  sub.pause();
+  Expect.equals(-paused, state);
+  Expect.isTrue(controller.isPaused);
+  sub.resume();
+  Expect.equals(-running, state);
+  Expect.isFalse(controller.isPaused);
+  sub.cancel();
+  Expect.equals(-canceled, state);
+}
+
+void testSettingNullCallbacks() {
+  failCallback() => fail("Callback should not be called");
+  var controller = new StreamController(onListen: failCallback,
+                                        onPause : failCallback,
+                                        onResume: failCallback,
+                                        onCancel: failCallback);
+
+  var stream = controller.stream;
+
+  Expect.isFalse(controller.hasListener);
+  Expect.isTrue(controller.isPaused);
+
+  controller.onListen = null;
+
+  var sub = stream.listen(null);
+
+  Expect.isTrue(controller.hasListener);
+  Expect.isFalse(controller.isPaused);
+
+  controller.onPause = null;
+
+  sub.pause();
+
+  Expect.isTrue(controller.hasListener);
+  Expect.isTrue(controller.isPaused);
+
+  controller.onResume = null;
+
+  sub.resume();
+
+  Expect.isTrue(controller.hasListener);
+  Expect.isFalse(controller.isPaused);
+
+  controller.onCancel = null;
+
+  sub.cancel();
+
+  Expect.isFalse(controller.hasListener);
+  Expect.isFalse(controller.isPaused);
+}
+
+void testBroadcastSettingCallbacks() {
+  const int initial = 0;
+  const int running = 1;
+  const int canceled = 2;
+
+  var controller = new StreamController.broadcast();
+  var stream = controller.stream;
+  var state = initial;
+
+  Expect.throws(() { controller.onPause = (){}; },
+                (e) => e is UnsupportedError);
+  Expect.throws(() { controller.onResume = (){}; },
+                (e) => e is UnsupportedError);
+
+  controller..onListen = () { state = running; }
+            ..onCancel = () { state = canceled; };
+
+  Expect.equals(initial, state);
+  var sub = stream.listen(null);
+  Expect.equals(running, state);
+  sub.cancel();
+  Expect.equals(canceled, state);
+
+  // Changing them later does make a difference.
+  controller..onListen = () { state = -running; }
+            ..onCancel = () { state = -canceled; };
+
+  var sub2 = stream.listen(null);
+  Expect.equals(-running, state);
+  sub2.cancel();
+  Expect.equals(-canceled, state);
+}
+
+void testBroadcastSettingNullCallbacks() {
+  failCallback() => fail("Callback should not be called");
+  var controller = new StreamController.broadcast(onListen: failCallback,
+                                                  onCancel: failCallback);
+
+  var stream = controller.stream;
+
+  Expect.isFalse(controller.hasListener);
+
+  controller.onListen = null;
+
+  var sub = stream.listen(null);
+
+  Expect.isTrue(controller.hasListener);
+
+  controller.onCancel = null;
+
+  sub.cancel();
+
+  Expect.isFalse(controller.hasListener);
+}
+
 main() {
   asyncStart();
   testMultiController();
   testSingleController();
   testExtraMethods();
   testClosed();
   testCloseFuture();
   testCloseFuture2();
   testCloseFuture3();
   testStreamEquals();
   testCancelThrow();
   testCancelThrow2();
   testCancelThrow3();
   testBroadcastListenAfterClose();
   testBroadcastListenAfterClosePaused();
   testAsBroadcastListenAfterClose();
   testAsBroadcastListenAfterClosePaused();
   testEventInListen();
   testSyncControllerNotReentrant();
+  testSettingCallbacks();
+  testSettingNullCallbacks();
+  testBroadcastSettingCallbacks();
+  testBroadcastSettingNullCallbacks();
   asyncEnd();
 }