anchor.diff:      Result := '';
   end;
   
  -class procedure Assert.AreEqual(const left, right: Integer; const message: string);
  -begin
  -  if left <> right then
  -    Fail(Format('left %d but got %d %s' ,[left, right, message]), ReturnAddress);
  -end;
  -
  -class procedure Assert.AreEqual(const left, right, tolerance: Double; const message: string);
  -begin
  -  if not Math.SameValue(left,right,tolerance) then
  -    Fail(Format('left %g but got %g %s' ,[left,right,message]), ReturnAddress);
  -end;
  -
  -class procedure Assert.AreEqual(const left, right: Double; const message: string);
  +class procedure Assert.AreEqual(const expected, actual: Integer; const message: string);
  +begin
  +  if expected <> actual then
  +    Fail(Format('Expected %d but got %d %s' ,[expected, actual, message]), ReturnAddress);
  +end;
  +
  +class procedure Assert.AreEqual(const expected, actual, tolerance: Double; 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: Double; const message: string);
   var
     tolerance : Double;
   begin
     tolerance := 0;
  -  AreEqual(left, right, tolerance, message);
  -end;
  -
  -class procedure Assert.AreEqual(const left, right: Extended; const message: string);
  +  AreEqual(expected, actual, tolerance, message);
  +end;
  +
  +class procedure Assert.AreEqual(const expected, actual: Extended; const message: string);
   var
     tolerance : Extended;
   begin
     tolerance := 0;
  -  AreEqual(left, right, tolerance, message);
  +  AreEqual(expected, actual, tolerance, message);
   end;
   
   class procedure Assert.AreEqualMemory(const left : Pointer; const right : Pointer; const size : Cardinal; const message : string);
  
positive.code:   Fail('Method did not throw any exceptions.' + AddLineBreak(msg), ReturnAddress);
  end;
  
  class procedure Assert.AreEqual(const left : string; const right : string; const message : string);
  begin
    Assert.AreEqual(left, right, true, message);
  end;
  
  class procedure Assert.AreEqual(const left, right : string;  const ignoreCase : boolean; const message: string);
  begin
    if ignoreCase then
    begin
      if not SameText(left,right) then
        Fail(Format('[%s] is Not Equal to [%s] %s',[left,right,message]), ReturnAddress);
    end
    else if not SameStr(left,right) then
        Fail(Format('[%s] is Not Equal to [%s] %s',[left,right,message]), ReturnAddress);
  end;
  
  class procedure Assert.CheckExceptionClass(E: Exception; const exceptionClass: ExceptClass);
  
negative.code: 
  {$IFDEF DELPHI_XE_UP}
      //Delphi 2010 compiler bug breaks this
  class procedure Assert.AreEqual<T>(const expected, actual: T; const message: string);
  var
    comparer : IComparer<T>;
    expectedValue, actualValue : TValue;
  begin
    comparer := TComparer<T>.Default;
    if comparer.Compare(actual,expected) <> 0 then
    begin
      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}
  