anchor.diff:        });
       });
   
  -    test('A Source may not have #emitEvent invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#emitEvent);
  -        });
  -    });
  -
  -    test('A Source may not have #addEventAction invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#addEventAction);
  -        });
  -    });
  -
  -    test('A Source may not have #removeEventAction invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#removeEventAction);
  -        });
  -    });
  -
  -    test('A Source may not have #listen invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#listen);
  -        });
  -    });
  -
  -    test('A Source may not have #ignoreSpecificEventBinding invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#ignoreSpecificEventBinding);
  -        });
  -    });
  -
  -    test('A Source may not have #ignoreAllEventsOfType invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#ignoreAllEventsOfType);
  -        });
  -    });
  -
  -    test('A Source may not have #ignoreAllEventsFrom invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        () => lastErrorCaughtDuringTest != null,
  -        (){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#ignoreAllEventsFrom);
  -        });
  -    });
  -
  -    test('A Source may not have #ignoreAllEvents invoked on it', (){
  -      expectAsyncWithReadyCheckAndTimeout(
  -        (){
  -        return lastErrorCaughtDuringTest != null;
  -        },(){
  -          expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true));
  -        });
  -      executeWhenReadyOrTimeout(
  -        () => currentTestConsumer != null,
  -        (){
  -          currentTestConsumer.callSourceMethod(#ignoreAllEvents, [null]);
  -        });
  -    });
  -
  -    test('A Source may not have a private method invoked on it', (){
  +    test('a Source may not have #emitEvent invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#emitEvent));
  +    });
  +
  +    test('a Source may not have #addEventAction invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#addEventAction));
  +    });
  +
  +    test('a Source may not have #removeEventAction invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#removeEventAction));
  +    });
  +
  +    test('a Source may not have #listen invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#listen));
  +    });
  +
  +    test('a Source may not have #ignoreSpecificEventBinding invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#ignoreSpecificEventBinding));
  +    });
  +
  +    test('a Source may not have #ignoreAllEventsOfType invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#ignoreAllEventsOfType));
  +    });
  +
  +    test('a Source may not have #ignoreAllEventsFrom invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#ignoreAllEventsFrom));
  +    });
  +
  +    test('a Source may not have #ignoreAllEvents invoked on it', (){
  +      expectAsyncWithReadyCheckAndTimeout(
  +        () => lastErrorCaughtDuringTest != null,
  +        () => expect(lastErrorCaughtDuringTest is core.RestrictedMethodError, equals(true)));
  +      executeWhenReadyOrTimeout(
  +        () => currentTestConsumer != null,
  +        () => currentTestConsumer.callSourceMethod(#ignoreAllEvents, [null]));
  +    });
  +
  +    test('a Source may not have a private method invoked on it', (){
         expectAsyncWithReadyCheckAndTimeout(
           () => lastErrorCaughtDuringTest != null,
           (){
  
positive.code: import 'package:purity/local.dart' as local;
  import 'dart:async';
  import 'dart:mirrors';
  
  void runEndToEndTests(){
  
  
negative.code:     setUp(_setUp);
      tearDown(_tearDown);
  
      test('a consumer can make calls to its source by proxy and receive events back by proxy', (){
        var pi = 3.142;
        executeWhenReadyOrTimeout(() => currentTestConsumer != null, () => currentTestConsumer.doStuff(pi));
        expectAsyncWithReadyCheckAndTimeout(
          () => lastEventDataCaughtByConsumer != null,
          () => expect(lastEventDataCaughtByConsumer.prop, equals(pi)));
      });
  
      test('EventEmiiter and EventDetector contain the expected methods', (){
  