anchor.diff:  
   {$IFDEF DELPHI_XE_UP}
       //Delphi 2010 compiler bug breaks this
  -class procedure Assert.AreEqual<T>(const left, right: T; const message: string);
  +class procedure Assert.AreEqual<T>(const expected, actual: T; const message: string);
   var
     comparer : IComparer<T>;
  -  leftvalue, rightvalue : TValue;
  +  expectedValue, actualValue : TValue;
   begin
     comparer := TComparer<T>.Default;
  -  if comparer.Compare(right,left) <> 0 then
  +  if comparer.Compare(actual,expected) <> 0 then
     begin
  -    leftValue := TValue.From<T>(left);
  -    rightValue := TValue.From<T>(right);
  -    Fail(Format('left %s is not equal to right %s %s', [leftValue.ToString, rightValue.ToString, message]), ReturnAddress)
  +    expectedValue := TValue.From<T>(expected);
  +    actualValue := TValue.From<T>(actual);
  +    Fail(Format('Expected %s is not equal to actual %s %s', [expectedValue.ToString, actualValue.ToString, message]), ReturnAddress)
     end;
   end;
   {$ENDIF}
  
positive.code:     class procedure Pass(const message : string = '');
      class procedure Fail(const message : string = ''; const errorAddrs : pointer = nil);
  
      class procedure AreEqual(const left : string; const right : string; const ignoreCase : boolean; const message : string = '');overload;
      class procedure AreEqual(const left : string; const right : string; const message : string = '');overload;
      class procedure AreEqual(const left, right : Double; const tolerance : Double; const message : string = '');overload;
      class procedure AreEqual(const left, right : Double; const message : string = '');overload;
      class procedure AreEqual(const left, right : Extended; const tolerance : Extended; const message : string = '');overload;
      class procedure AreEqual(const left, right : Extended; const message : string = '');overload;
      class procedure AreEqual(const left, right : TClass; const message : string = '');overload;
  {$IFDEF DELPHI_XE_UP}
      //Delphi 2010 compiler bug breaks this
      class procedure AreEqual<T>(const left, right : T; const message : string = '');overload;
  {$ENDIF}
      class procedure AreEqual(const left, right : Integer; const message : string = '');overload;
      class procedure AreEqual(const left, right : boolean; const message : string = '');overload;
  
      class procedure AreEqualMemory(const left : Pointer; const right : Pointer; const size : Cardinal; const message : string = '');
  
  
negative.code: 
  { Assert }
  
  class procedure Assert.AreEqual(const expected, actual, tolerance: Extended; const message: string);
  begin
    if not Math.SameValue(expected,actual,tolerance) then
      Fail(Format('Expected %g but got %g %s' ,[expected,actual,message]), ReturnAddress);
  end;
  
  
  class procedure Assert.AreEqual(const expected, actual: TClass; const message: string);
  var
    msg : string;
  begin
    if expected <> actual then
    begin
      msg := ' is not equal to ';
      if expected = nil then
        msg := 'nil' + msg
      else
        msg := expected.ClassName + msg;
  
      if actual = nil then
        msg := msg +  'nil'
      else
        msg := msg + actual.ClassName;
  
      if message <> '' then
        msg := msg + '. ' + message;
  