anchor.diff:    Result := TDUnitXTestResult.Create(testInfo, TTestResultType.Pass, aMessage, aLogMessages);
   end;
   
  -procedure TDUnitXTestRunner.ExecuteTearDownFixtureMethod(const context: ITestExecuteContext; const threadId: TThreadID; const fixture: ITestFixture);
  +procedure TDUnitXTestRunner.ExecuteTearDownFixtureMethod(const context: ITestExecuteContext; const threadId: TThreadID; const fixture: ITestFixture; const fixtureResult: IFixtureResult);
   begin
     try
       Self.Loggers_TeardownFixture(threadId, fixture as ITestFixtureInfo);
       fixture.ExecuteFixtureTearDown; //deals with destructors in a way that stops memory leak reporting from reporting bogus leaks.
  +    Self.Loggers_EndTearDownFixture(threadId, fixture as ITestFixtureInfo);
     except
       on e: Exception do
       begin
  -      //TODO: ExecuteErrorResult(context, threadId, test, 'Test does not support ITestExecute');
  -      Log(TLogLevel.Error, Format(SFixtureTeardownError, [fixture.Name,e.Message]));
  -      raise;
  +      InvalidateTestsInFixture(fixture, context, threadId, e, fixtureResult);
  +      Log(TLogLevel.Error, Format(SFixtureTeardownError, [fixture.Name, e.Message]));
       end;
     end;
   end;
  
positive.code:     function ExecuteTimedOutResult(const context: ITestExecuteContext; const threadId: TThreadID; const test: ITest; const exception: Exception; const aLogMessages: TLogMessageArray) : ITestError;
      function ExecuteErrorResult(const context: ITestExecuteContext; const threadId: TThreadID; const test: ITest; const exception: Exception; const aLogMessages: TLogMessageArray): ITestError;
      function ExecuteIgnoredResult(const context: ITestExecuteContext; const threadId: TThreadID; const test: ITest; const ignoreReason: string): ITestResult;
  
      function CheckMemoryAllocations(const test: ITest; out errorResult: ITestResult; const memoryAllocationProvider: IMemoryLeakMonitor): boolean;
  
      function ExecuteTestTearDown(const context: ITestExecuteContext; const threadId: TThreadID; const fixture: ITestFixture; const test: ITest; out errorResult: ITestResult; const memoryAllocationProvider: IMemoryLeakMonitor): boolean;
      procedure ExecuteTearDownFixtureMethod(const context: ITestExecuteContext; const threadId: TThreadID; const fixture: ITestFixture);
  
      procedure RecordResult(const context: ITestExecuteContext; const threadId: TThreadID; const fixtureResult: IFixtureResult; const testResult: ITestResult);
  
  
negative.code: function TDUnitXTestRunner.GetUseRTTI: Boolean;
  begin
    result := FUseRTTI;
  end;
  
  procedure TDUnitXTestRunner.InvalidateTestsInFixture(const aFixture: ITestFixture; const aContext: ITestExecuteContext; const aThreadId: TThreadID; const aException: Exception; const aFixtureResult: IFixtureResult);
  var
    lTest: ITest;
    lTestResult: ITestResult;
  begin
    for lTest in aFixture.Tests do
    begin
      if not ShouldRunThisTest(lTest) then
        Continue;
  
      Self.Loggers_BeginTest(aThreadId, lTest as ITestInfo);
      lTestResult := ExecuteErrorResult(aContext, aThreadId, lTest, aException, FLogMessagesEx);
      RecordResult(aContext, aThreadId, aFixtureResult, lTestResult);
      Self.Loggers_EndTest(aThreadId, lTestResult);
    end;
  end;
  
  procedure TDUnitXTestRunner.SetFailsOnNoAsserts(const value: boolean);
  