mORMot Open Source

Will not work - see this code:

type
  autofree = record
    class operator finalize(var value: autofree);
  end;

class operator autofree.finalize(var value: autofree);
begin
  Writeln('finalize');
end;

function get: autofree;
begin
end;

procedure Main(const i: Integer);
begin
  if i = 42 then
    get;
  Writeln('end');
end;

begin
  Main(42);
  Readln;
end.

Will write 'finalize' before 'end'

FWIW it was this bug that caused this: http://qc.embarcadero.com/wc/qcmain.aspx?d=79943

I was looking into this approach for some feature I am implementing currently as it seemed the most practical solution to my problem (per class metadata similar to your use case).
However I only know how to write protected memory on Windows and not how that would be done on the Mobile platforms. Do you have any information about that?

Yeah, for over ten years now...

What I am missing with all these recent performance comparisons is an exact analysis what makes the difference if there is one and what parts could be improved.
Like for example you say D7 is fastest which is because of the optimized RTL. I see a different of like 10% give or take between D7 and XE6.
Is it really the RTL that is making these 10%? Or is it something different? Maybe the RTL would make 20% but the generated code got 10% worse?

So imho without further analysis we can only guess and claim that poor code generation in some parts are "slowing it down" and that compiler X or Y is sooo much better.

The problem in this case is not even the missing member of the class type.
What is missing is additional RTTI for generic types (like the typeinfo for the generic parameters) just similar to the information you get for array types.

When you have a argument of the type IList<TClient> you have to retrieve the type info for TClient to be able to create instances of that class when deserializing.

In that case you can use a class like I posted above.

Currently afaik you only can get the generic parameter by analyzing the class name (in our example extract the TClient from IList<TClient> and then iterate all known types and compare it - but even then you cannot be sure if you get the correct type unless its a public type which is fully qualified).

Anyway I got the IList<T> support partially working - just trying to solve the problem I just explained.

The problem is when the client side exclusively works with IList<> as our software currently does (would be the same if we were using the Generics.Collections ones though). That would mean extra work to create wrappers which mORMot can work with.
So the better way imo would be to work with these types directly. So what this needs is some mechanism to register custom types if you don't want the framework to have more dependencies than needed (which I understand) - I guess this is also responsible for creating the instances on the server side (haven't looked into it yet).

Of course with generics this is a bit more complicated as you cannot just register a type info.

You can take a look at Spring4d as I was talking about those IList<T> types (http://code.google.com/p/delphi-spring- … ctions.pas).

IList<T> inherits from IEnumerable which has the GetElementType method that returns the PTypeInfo of T.
T can basically be any type but I am mostly interested in class types.

So I can write a service that has methods like:

function LoadCustomers(out customers: IList<TCustomer>): Boolean

But this already fails at startup because interface parameters are currently not supported.

Is there a way of using TInterfaceStub or TInterfaceObjectFake to create a proxy for an interface by just specifying the OnInvoke callback (just like you can do with TVirtualInterface)?

With TVirtualInterface I can create something like this (quick & dirty implementation):

  TVirtualInterface.Create(TypeInfo(IMyInterface),
    procedure(Method: TRttiMethod; const Args: TArray<TValue>; out Result: TValue)
    var
      LArgs: TArray<TValue>;
      i: Integer;
    begin
      SetLength(LArgs, Length(Args) - 1);
      for i := Low(LArgs) to High(LArgs) do
        LArgs[i] := Args[i + 1];
      Result := Method.Invoke(TValue.From<IInterface>(instance), LArgs);
    end).QueryInterface(IMyInterface, proxy);

I was talking about the IFoo.Bar signature. If you have a unit test which just includes the interface definition which has been changed, it will compile for sure.

Yes, I was just referring to the execution. The caching of the rtti information could be done in my implementation aswell but currently I am more focused on the execution speed (since I am using this whole mechanism for AOP provided by a DI container).

Thanks for explanation.

I made a quick test to see how it feels compared to my solution.

Here is what i wrote:

unit TestFoo;

interface

uses
  TestFramework, mORMot;

type
  TFooTestCase = class(TTestCase)
  private
    function ExecuteBar(var Params: TOnInterfaceStubExecuteParams): Boolean;
  published
    procedure TestBar;
  end;

implementation

uses
  Diagnostics,
  DSharp.Testing.Mock,
  SynCommons,
  SysUtils;

type
  {$M+}
  IFoo = interface
    ['{26D6D411-5994-4EEB-8EE1-9D6DCA8D5EA8}']
    function Bar(var i: Integer): Integer;
  end;

function TFooTestCase.ExecuteBar(var Params: TOnInterfaceStubExecuteParams): Boolean;
var
  P: PUTF8Char;
begin
  P := Pointer(Params.Params);
  Params.Params := IntToString(GetNextItemCardinal(P) + 1);
  Params.Result := '[42]';
  Result := True;
end;

{ TFooTestCase }

procedure TFooTestCase.TestBar;
const
  CallCount = 100000;
var
  foo: IFoo;

  fooMock: Mock<IFoo>;

  sw: TStopwatch;
  i, k: Integer;
begin
  k := 0;

  sw := TStopwatch.StartNew;

  TInterfaceStub.Create(TypeInfo(IFoo), foo).Executes('Bar', ExecuteBar);

  for i := 1 to CallCount do
  begin
    CheckEquals(42, foo.Bar(k));
    CheckEquals(i, k);
  end;

  Status(Format('mORMot: %d ms', [sw.ElapsedMilliseconds]));

  // -------------------------------------------

  k := 0;

  sw := TStopwatch.StartNew;

  fooMock.WillExecute(
    function(var Args: array of TValue): TValue
    begin
      Result := 42;
      Args[0] := Args[0].AsInteger + 1;
    end).Any.WhenCallingWithAnyArguments.Bar(k);
  foo := fooMock;

  for i := 1 to CallCount do
  begin
    CheckEquals(42, foo.Bar(k));
    CheckEquals(i, k);
  end;

  Status(Format('DSharp: %d ms', [sw.ElapsedMilliseconds]));
end;

initialization
  RegisterTest(TFooTestCase.Suite);
  
end.

You said, RTTI cannot handle var and out parameters. That is not true (at least not with my implementation).

This code does not run it raises "EInterfaceFactoryException at  $0052CF3B Invalid "IFoo" interface call: returned item".

mORMot is approx 4-5 times faster than the DSharp implementation.

While it's great that mORMot runs on older Delphi versions its handling is really ugly imho as you can see in the ExecuteBar method (if it would work).
I think the TOnInterfaceStubExecuteParams should provide the params and the result in an easier to use way (like Variants or something like that).

Imo the benefit of having to pass the parameter is that you can easily define expectations for matching parameters.
If you don't care about parameters just say so (I called the method WhenCallingWithAnyArguments in my mocks) and pass dummy values (empty string, 0, nil, ...).

Renaming a method or changing signature will cause the test to fail at runtime, not at compiletime. And that is for every test that uses a mock of the changed interface.

Using strings as identifier is one of the major weak points of certain mock frameworks, while others solve that problem by avoiding that.

I think even without generics (although they allow a much nicer fluent interface style to define expectations) this is possible (not perfect though)

procedure TMyTest.ForgotMyPassword;
var
  SmsSender: ISmsSender;
  UserRepository: IUserRepository;
begin
  TInterfaceStub.Create(TypeInfo(ISmsSender), SmsSender);
  When(SmsSender.Send()).Returns(True);
  TInterfaceMock.Create(TypeInfo(IUserRepository), UserRepository, Self);
  When(UserRepository.Save()).ExpectsCount(qoEqualTo, 1);
  with TLoginController.Create(UserRepository, SmsSender) do
  try
    ForgotMyPassword('toto');
  finally
    Free;
  end;
end;

The method call to the mock/stub interface which is done before calling When captures the method/instance and Returns and ExpectsCount apply the expectation to this method/instance.
This should work down to Delphi 6 for any function with the matching overloads for When, just not for procedures.

Edit: changed the order of the calls