anchor.diff:    _purityTestTranTypesRegistered = true;
     registerTranTypes('purity.test', 'pt',(){
       registerTranSubtype('a', TestEvent);
  +    registerTranSubtype('b', MassiveObjectDeleted);
  +    registerTranSubtype('c', MassiveObjectCreated);
     });
   }
   
  +const int ciriticalMassivesToCrash = 25;
   bool restrictedAccessMethodCalled = false;
  +bool memoryLeakTestComplete = false;
   local.Host currentHost;
   local.ProxyEndPoint currentproxyEndPoint;
   TestSource currentTestSrc;
   TestConsumer currentTestConsumer;
   dynamic srcPassedToConsumer;
   dynamic lastErrorCaughtDuringTest;
  -TestEvent lastEventDataCaughtByConsumer;
  +dynamic lastEventDataCaughtByConsumer;
   
   void _setUp(){
   
  
positive.code:         });
      });
  
    });
  
  }
  
  
  class TestSource extends Source{
  
    void doStuff(x){
      emitEvent(
        new TestEvent()
        ..prop = x);
    }
  }
  
  class TestConsumer extends Consumer{
    TestConsumer(src):super(src){
      listen(src, Omni, (Event event){
        lastEventDataCaughtByConsumer = event.data;
      });
    }
  
  
negative.code:       });
      });
  
      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,
          (){
  