implemented support for more types in parameter matching

Author: sglienke

Source/Base/Spring.pas

@@ -5974,6 +5974,13 @@ function EqualsClass2Class(const left, right: TValue): Boolean;
   Result := left.AsObject = right.AsObject;
 end;
 
+function EqualsMeth2Meth(const left, right: TValue): Boolean;
+begin
+  Result := (left.TypeInfo = right.TypeInfo)
+    and (TValueData(left).FAsMethod.Code = TValueData(right).FAsMethod.Code)
+    and (TValueData(left).FAsMethod.Data = TValueData(right).FAsMethod.Data);
+end;
+
 function EqualsPointer2Pointer(const left, right: TValue): Boolean;
 begin
   Result := left.AsPointer = right.AsPointer;
@@ -6190,7 +6197,7 @@ function EqualsSet2Set(const left, right: TValue): Boolean;
       // tkUnknown, tkInteger, tkChar, tkEnumeration, tkFloat,
       EqualsFail, EqualsFail, EqualsFail, EqualsFail, EqualsFail,
       // tkString, tkSet, tkClass, tkMethod, tkWChar,
-      EqualsFail, EqualsFail, EqualsFail, EqualsFail, EqualsFail, // TODO: tkMethod
+      EqualsFail, EqualsFail, EqualsFail, EqualsMeth2Meth, EqualsFail, // TODO: tkMethod
       // tkLString, tkWString, tkVariant, tkArray, tkRecord,
       EqualsFail, EqualsFail, EqualsFail, EqualsFail, EqualsFail,
       // tkInterface, tkInt64, tkDynArray, tkUString, tkClassRef

Source/Core/Mocking/Spring.Mocking.Matching.pas

@@ -383,10 +383,10 @@ class function TMatcherFactory.GetIndex(const v: TValue): Integer;
 const
   Handlers: array[TTypeKind] of function(const v: TValue): Integer = (
     GetIndexFail, GetIndexOrdinal, GetIndexOrdinal, GetIndexOrdinal, GetIndexFloat,
-    GetIndexFail, GetIndexOrdinal, GetIndexObject, GetIndexFail, GetIndexString,
+    GetIndexFail, GetIndexOrdinal, GetIndexObject, GetIndexPointer, GetIndexString,
     GetIndexString, GetIndexString, GetIndexVariant, GetIndexArray, GetIndexRecord,
-    GetIndexInterface, GetIndexOrdinal, GetIndexArray, GetIndexString, GetIndexFail,
-    GetIndexObject, GetIndexFail {$IF Declared(tkMRecord)}, GetIndexFail{$IFEND});
+    GetIndexInterface, GetIndexOrdinal, GetIndexArray, GetIndexString, GetIndexPointer,
+    GetIndexObject, GetIndexPointer {$IF Declared(tkMRecord)}, GetIndexRecord{$IFEND});
 begin
   Result := Handlers[TValueData(v).FTypeInfo.Kind](v) - 1;
 end;
@@ -395,10 +395,10 @@ class procedure TMatcherFactory.SetIndex(typeInfo: PTypeInfo; index: Integer; va
 const
   Handlers: array[TTypeKind] of procedure (typeInfo: PTypeInfo; index: Integer; var Result) = (
     SetIndexFail, SetIndexOrdinal, SetIndexOrdinal, SetIndexOrdinal, SetIndexFloat,
-    SetIndexFail, SetIndexOrdinal, SetIndexObject, SetIndexFail, SetIndexString,
+    SetIndexFail, SetIndexOrdinal, SetIndexObject, SetIndexPointer, SetIndexString,
     SetIndexString, SetIndexString, SetIndexVariant, SetIndexArray, SetIndexRecord,
-    SetIndexInterface, SetIndexOrdinal, SetIndexArray, SetIndexString, SetIndexFail,
-    SetIndexObject, SetIndexFail {$IF Declared(tkMRecord)}, SetIndexFail{$IFEND});
+    SetIndexInterface, SetIndexOrdinal, SetIndexArray, SetIndexString, SetIndexPointer,
+    SetIndexObject, SetIndexPointer {$IF Declared(tkMRecord)}, SetIndexRecord{$IFEND});
 begin
   Handlers[typeInfo.Kind](typeInfo, index + 1, Result);
 end;

Tests/Source/Core/Spring.Tests.Mocking.pas

@@ -34,6 +34,8 @@ interface
 
 type
   TParameterMatchingTests = class(TTestCase)
+  private
+    procedure Notify(Sender: TObject);
   published
     procedure ArgsEvaluationOrder;
     procedure ArgsStackProperlyCleaned;
@@ -48,6 +50,11 @@   TParameterMatchingTests = class(TTestCase)
     procedure TestRegex;
     procedure TestEnum;
     procedure TestSet;
+    procedure TestClass;
+    procedure TestMethod;
+    {$IFDEF DELPHIX_SYDNEY_UP}
+    procedure TestMRecord;
+    {$ENDIF}
 
     procedure ReturnsMultipleValues;
     procedure WrapperObjectsNotLeaking;
@@ -88,6 +95,7 @@   MockSequenceTest = class(TTestCase)
 implementation
 
 uses
+  Classes,
   SysUtils,
   Spring,
   Spring.Mocking;
@@ -96,6 +104,16 @@ implementation
   TTestEnum = (One, Two, Three);
   ShortEnum = 0..31;
   TTestSet = set of {$IFNDEF DELPHIX_RIO_UP}ShortEnum{$ELSE}Byte{$ENDIF}; // see RSP-16153
+  {$IFDEF DELPHIX_SYDNEY_UP}
+  TTestMRec = record
+    value: Integer;
+    class operator Initialize(out value: TTestMRec);
+  end;
+  {$M+}
+  IMockTestMRec = interface
+    procedure Test(const rec: TTestMRec);
+  end;
+  {$ENDIF}
 
   {$M+}
   IMockTest = interface
@@ -109,6 +127,8 @@ implementation
     procedure TestEnum(const value: TTestEnum);
     procedure TestSet(const n: Integer; const value: TTestSet; const i: Integer = 0);
     procedure TestObject(const obj: TObject);
+    procedure TestClass(const cls: TClass);
+    procedure TestMethod(const event: TNotifyEvent);
     function GetNext: Integer;
 
     function GetEvent: IInvokableNotifyEvent<Integer>;
@@ -150,6 +170,17 @@   TFoo = class
   end;
 
 
+{$REGION 'TTestMRec'}
+
+{$IFDEF DELPHIX_SYDNEY_UP}
+class operator TTestMRec.Initialize(out value: TTestMRec);
+begin
+end;
+{$ENDIF}
+
+{$ENDREGION}
+
+
 {$REGION 'TParameterMatchingTests'}
 
 procedure TParameterMatchingTests.ArgsEvaluationOrder;
@@ -237,6 +268,10 @@ procedure TParameterMatchingTests.ArgsStackProperlyCleaned;
   Pass;
 end;
 
+procedure TParameterMatchingTests.Notify(Sender: TObject);
+begin
+end;
+
 procedure TParameterMatchingTests.OutParameterCanBePassed;
 {$IFDEF DELPHIXE8_UP}
 var
@@ -306,6 +341,19 @@ procedure TParameterMatchingTests.ReturnsMultipleValues;
   mock.Instance.GetNumber;
 end;
 
+procedure TParameterMatchingTests.TestClass;
+var
+  mock: Mock<IMockTest>;
+begin
+  mock.Setup.Executes.When.TestClass(TObject);
+  mock.Instance.TestClass(TObject);
+  mock.Received.TestClass(TObject);
+  mock.Setup.Executes.When.TestClass(Arg.IsAny<TClass>);
+  mock.Instance.TestClass(nil);
+  mock.Received.TestClass(nil);
+  Pass;
+end;
+
 procedure TParameterMatchingTests.TestDynArray;
 var
   mock: Mock<IMockTest>;
@@ -332,6 +380,35 @@ procedure TParameterMatchingTests.TestEnum;
   Pass;
 end;
 
+procedure TParameterMatchingTests.TestMethod;
+var
+  mock: Mock<IMockTest>;
+begin
+  mock.Setup.Executes.When.TestMethod(Notify);
+  mock.Instance.TestMethod(Notify);
+  mock.Received.TestMethod(Notify);
+  mock.Setup.Executes.When.TestMethod(Arg.IsAny<TNotifyEvent>());
+  mock.Instance.TestMethod(nil);
+  mock.Received.TestMethod(nil);
+  Pass;
+end;
+
+{$IFDEF DELPHIX_SYDNEY_UP}
+procedure TParameterMatchingTests.TestMRecord;
+var
+  mock: Mock<IMockTestMRec>;
+  rec: TTestMRec;
+begin
+  mock.Setup.Executes.When.Test(rec);
+  mock.Instance.Test(rec);
+  mock.Received.Test(rec);
+  mock.Setup.Executes.When.Test(Arg.IsAny<TTestMRec>);
+  mock.Instance.Test(rec);
+  mock.Received(2).Test(Arg.IsAny<TTestMRec>);
+  Pass;
+end;
+{$ENDIF}
+
 procedure TParameterMatchingTests.TestRecord;
 var
   mock: Mock<TFoo>;