anchor.diff:    test('conflicting transitions', () {
       var controller = new StreamController.broadcast(sync: true);
   
  -    var machine = new Machine();
  +    try {
  +      var machine = new Machine();
   
  -    var stateA = machine.newState('a');
  -    var stateB = machine.newState('b');
  -    var stateC = machine.newState('c');
  +      var stateA = machine.newState('a');
  +      var stateB = machine.newState('b');
  +      var stateC = machine.newState('c');
   
  -    stateA.onStream(controller.stream, (value) => stateB.enter());
  -    stateA.onStream(controller.stream, (value) => stateC.enter());
  +      stateA.onStream(controller.stream, (value) => stateB.enter());
  +      stateA.onStream(controller.stream, (value) => stateC.enter());
   
  -    machine.start();
  -    controller.add('*');
  -    expect(machine.current, stateB);
  +      machine.start();
  +      controller.add('*');
  +      expect(machine.current, stateB);
  +    } finally {
  +      controller.close();
  +    }
     });
     test('future transitions', () {
       var machine = new Machine();
  
positive.code:     var stateB = machine.newState('b');
      var stateC = machine.newState('c');
  
      stateA.onTimeout(
          new Duration(milliseconds: 10),
          expectAsync0(() {
            expect(machine.current, stateA);
            stateB.enter();
          }));
      stateA.onTimeout(
          new Duration(milliseconds: 20),
          () => fail('should never be called'));
      stateB.onTimeout(
          new Duration(milliseconds: 20),
          () => fail('should never be called'));
      stateB.onTimeout(
          new Duration(milliseconds: 10),
          expectAsync0(() {
            expect(machine.current, stateB);
            stateC.enter();
          }));
  
      machine.start();
    });
  
negative.code: 
  void main() {
    group('stream transitions', () {
      StreamController controllerA, controllerB, controllerC;
      Machine machine;
      State stateA, stateB, stateC;
  
      setUp(() {
        controllerA = new StreamController.broadcast(sync: true);
        controllerB = new StreamController.broadcast(sync: true);
        controllerC = new StreamController.broadcast(sync: true);
  
        machine = new Machine();
  
        stateA = machine.newState('a');
        stateB = machine.newState('b');
        stateC = machine.newState('c');
  
        stateA.onStream(controllerB.stream, (event) => stateB.enter());
        stateA.onStream(controllerC.stream, (event) => stateC.enter());
  
        stateB.onStream(controllerA.stream, (event) => stateA.enter());
        stateB.onStream(controllerC.stream, (event) => stateC.enter());
  
        stateC.onStream(controllerA.stream, (event) => stateA.enter());
        stateC.onStream(controllerB.stream, (event) => stateB.enter());
      });
      tearDown(() {
        controllerA.close();
        controllerB.close();
        controllerC.close();
      });
  
      test('string', () {
        expect(machine.toString(), 'Instance of \'Machine\'[null]');
  