lazarus-ccr/wst/trunk/tests/test_suite/test_support.pas

{   This file is part of the Web Service Toolkit
    Copyright (c) 2006, 2007 by Inoussa OUEDRAOGO

    This file is provide under modified LGPL licence
    ( the files COPYING.modifiedLGPL and COPYING.LGPL).


    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
}
{$INCLUDE wst_global.inc}
unit test_support;

interface

uses
  Classes, SysUtils,
{$IFDEF FPC}
  fpcunit, testregistry,
{$ELSE}
  TestFrameWork,
{$ENDIF}
  TypInfo,
  wst_types, base_service_intf;

type

  TTestEnum = ( teOne, teTwo, teThree, teFour );
  
  { TClass_B }

  TClass_B = class(TBaseComplexRemotable)
  private
    FVal_32S: LongInt;
    FVal_32U: LongWord;
    FVal_64S: Int64;
    FVal_64U: QWord;
    FVal_8S: ShortInt;
    FVal_8U: Byte;
    FVal_16S: SmallInt;
    FVal_16U: Word;
    FVal_Bool: Boolean;
    FVal_Enum: TTestEnum;
    FVal_String: string;
  Published
    property Val_Enum : TTestEnum Read FVal_Enum Write FVal_Enum;
    property Val_Bool : Boolean Read FVal_Bool Write FVal_Bool;
    property Val_String : string Read FVal_String Write FVal_String;

    property Val_8U : Byte Read FVal_8U Write FVal_8U;
      property Val_8S : ShortInt Read FVal_8S Write FVal_8S;
    property Val_16U : Word Read FVal_16U Write FVal_16U;
      property Val_16S : SmallInt Read FVal_16S Write FVal_16S;
    property Val_32U : LongWord Read FVal_32U Write FVal_32U;
      property Val_32S : LongInt Read FVal_32S Write FVal_32S;
    property Val_64U : QWord Read FVal_64U Write FVal_64U;
      property Val_64S : Int64 Read FVal_64S Write FVal_64S;
  End;
  
  { TClass_A }

  TClass_A = class(TBaseComplexRemotable)
  private
    FVal_32S: LongInt;
    FVal_32U: LongWord;
    FVal_64S: Int64;
    FVal_64U: QWord;
    FVal_8S: ShortInt;
    FVal_8U: Byte;
    FVal_16S: SmallInt;
    FVal_16U: Word;
    FVal_Bool: Boolean;
    FVal_Enum: TTestEnum;
    FVal_Obj: TClass_B;
    FVal_String: string;
    FVal_StringArray: TArrayOfStringRemotable;
  public
    constructor Create();override;
    destructor Destroy();override;
  Published
    property Val_Enum : TTestEnum Read FVal_Enum Write FVal_Enum;
    property Val_Bool : Boolean Read FVal_Bool Write FVal_Bool;
    property Val_String : string Read FVal_String Write FVal_String;

    property Val_8U : Byte Read FVal_8U Write FVal_8U;
      property Val_8S : ShortInt Read FVal_8S Write FVal_8S;
    property Val_16U : Word Read FVal_16U Write FVal_16U;
      property Val_16S : SmallInt Read FVal_16S Write FVal_16S;
    property Val_32U : LongWord Read FVal_32U Write FVal_32U;
      property Val_32S : LongInt Read FVal_32S Write FVal_32S;
    property Val_64U : QWord Read FVal_64U Write FVal_64U;
      property Val_64S : Int64 Read FVal_64S Write FVal_64S;
      
    property Val_Obj : TClass_B read FVal_Obj write FVal_Obj;
    property Val_StringArray : TArrayOfStringRemotable read FVal_StringArray write FVal_StringArray;
  End;

  TArrayOfClass_A = class(TBaseObjectArrayRemotable)
  private
    function GetItem(AIndex: Integer): TClass_A;
  public
    class function GetItemClass():TBaseRemotableClass;override;
    property Item[AIndex:Integer] : TClass_A Read GetItem;Default;
  end;
  
  { TTest_TBaseComplexRemotable }

  TTest_TBaseComplexRemotable = class(TTestCase)
  protected
    procedure Compare(const a,b : TClass_A);overload;
    procedure Compare(const a,b : TClass_B);overload;
  published
    procedure test_Assign();
    procedure Equal();
  end;
  
  { TTest_TBaseArrayRemotable }

  TTest_TBaseArrayRemotable = class(TTestCase)
  protected
    class function CreateArray() : TBaseArrayRemotable;virtual;abstract;
    class function GetTypeInfo() : PTypeInfo;virtual;abstract;
  published
    procedure Length_procs();
    procedure GetItemTypeInfo();
  end;
  
  { TTest_TArrayOfStringRemotable }

  TTest_TArrayOfStringRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
    procedure Equal();
  end;

  { TTest_TArrayOfBooleanRemotable }

  TTest_TArrayOfBooleanRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;

  { TTest_TArrayOfInt8URemotable }

  TTest_TArrayOfInt8URemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TArrayOfInt8SRemotable }

  TTest_TArrayOfInt8SRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TArrayOfInt16SRemotable }

  TTest_TArrayOfInt16SRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;

  { TTest_TArrayOfInt16URemotable }

  TTest_TArrayOfInt16URemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TArrayOfInt32URemotable }

  TTest_TArrayOfInt32URemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TArrayOfInt32SRemotable }

  TTest_TArrayOfInt32SRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;

  { TTest_TArrayOfInt64SRemotable }

  TTest_TArrayOfInt64SRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;

  { TTest_TArrayOfInt64URemotable }

  TTest_TArrayOfInt64URemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TArrayOfFloatSingleRemotable }

  TTest_TArrayOfFloatSingleRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;

  { TTest_TArrayOfFloatDoubleRemotable }

  TTest_TArrayOfFloatDoubleRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;

  { TTest_TArrayOfFloatExtendedRemotable }

  TTest_TArrayOfFloatExtendedRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TArrayOfFloatCurrencyRemotable }

  TTest_TArrayOfFloatCurrencyRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
  published
    procedure test_Assign();
    procedure GetItemAndSetItem();
  end;
  
  { TTest_TBaseObjectArrayRemotable }

  TTest_TBaseObjectArrayRemotable = class(TTest_TBaseArrayRemotable)
  protected
    class function CreateArray() : TBaseArrayRemotable;override;
    class function GetTypeInfo() : PTypeInfo;override;
    class procedure FillRandomItem(const AItem : TBaseRemotable);
    procedure CompareItem(const A,B : TBaseRemotable);
    procedure Compare(const a,b : TClass_A);overload;
    procedure Compare(const a,b : TClass_B);overload;
  published
    procedure test_Assign();
    procedure Equal();
  end;
  
  { TTest_TDateRemotable }

  TTest_TDateRemotable = class(TTestCase)
  published
    procedure FormatDate();
    procedure FormatDate_ZERO();
    procedure ParseDate();
    procedure Assign();
    procedure Equal();
  end;

  { TTest_TDurationRemotable }

  TTest_TDurationRemotable = class(TTestCase)
  published
    procedure FormatDate();
    procedure ParseDate();
  end;

  { TTest_TTimeRemotable }

  TTest_TTimeRemotable = class(TTestCase)
  published
    procedure FormatDate();
    procedure ParseDate();
  end;
  
  { TTest_TStringBufferRemotable }

  TTest_TStringBufferRemotable = class(TTestCase)
  published
    procedure test_Assign();
    procedure Equal();
  end;
  
  { TTest_TBase64StringRemotable }

  TTest_TBase64StringRemotable = class(TTestCase)
  published
    procedure test_Assign();
    procedure Equal();
    procedure SetBinaryData();
    procedure SetEncodedString();
  end;

  { TTest_TBase64StringExtRemotable }

  TTest_TBase64StringExtRemotable = class(TTestCase)
  published
    procedure Equal();
    procedure test_Assign();
    procedure SetBinaryData();
    procedure SetEncodedString();
  end;
  
implementation
uses Math, basex_encode;

function RandomValue(const AMaxlen: Integer): ansistring;
var
  k : Integer;
begin
  SetLength(Result,AMaxlen);
  for k := 1 to AMaxlen do begin
    Result[k] := Char((Random(Ord(High(Char)))));
  end;
end;

{ TArrayOfClass_A }

function TArrayOfClass_A.GetItem(AIndex: Integer): TClass_A;
begin
  Result := Inherited GetItem(AIndex) As TClass_A;
end;

class function TArrayOfClass_A.GetItemClass(): TBaseRemotableClass;
begin
  Result:= TClass_A;
end;

{ TTest_TBaseArrayRemotable }

procedure TTest_TBaseArrayRemotable.Length_procs();
const ITER : Integer = 1000;
var
  localObj : TBaseArrayRemotable;
  i : Integer;
  ok : Boolean;
begin
  localObj := CreateArray();
  try
    CheckEquals(0,localObj.Length);
    CheckEquals(0,localObj.Length);

    localObj.SetLength(0);
    CheckEquals(0,localObj.Length);

    ok := False;
    try
      localObj.SetLength(-10);
    except
      on e : EBaseRemoteException do
        ok := True;
    end;
    CheckEquals(True,ok);

    localObj.SetLength(ITER);
      CheckEquals(ITER,localObj.Length);

    for i := 0 to ITER do begin
      localObj.SetLength(i);
      CheckEquals(i,localObj.Length);
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

procedure TTest_TBaseArrayRemotable.GetItemTypeInfo();
var
  localObj : TBaseArrayRemotable;
  a, b : PTypeInfo;
begin
  localObj := CreateArray();
  try
    a := GetTypeInfo();
    b := localObj.GetItemTypeInfo();
    CheckEquals(a^.Name,b^.Name);
    CheckEquals(Ord(a^.Kind),Ord(b^.Kind));
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfStringRemotable }

class function TTest_TArrayOfStringRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfStringRemotable.Create();
end;

class function TTest_TArrayOfStringRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(ansistring);
end;

procedure TTest_TArrayOfStringRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfStringRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfStringRemotable.Create();
  try
    b := TArrayOfStringRemotable.Create();
    a.Assign(nil);
    
    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := RandomValue(Random(500));
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],b[k]);
        end;
      end;
      
      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfStringRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfStringRemotable;
  i, j, k : Integer;
  a : array of ansistring;
begin
  localObj := TArrayOfStringRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := RandomValue(Random(500));
        end;
        
        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

procedure TTest_TArrayOfStringRemotable.Equal();
const ITER : Integer = 100;
var
  a, b : TArrayOfStringRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfStringRemotable.Create();
  try
    b := TArrayOfStringRemotable.Create();

    CheckEquals(True,a.Equal(b));
    CheckEquals(True,b.Equal(a));

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      b.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := RandomValue(1 + Random(500));
          CheckEquals(False,a.Equal(b));
          CheckEquals(False,b.Equal(a));
          b[k] := a[k];
          CheckEquals(True,a.Equal(b));
          CheckEquals(True,b.Equal(a));
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

{ TTest_TBaseComplexRemotable }

procedure TTest_TBaseComplexRemotable.Compare(const a, b: TClass_A);
var
  i, c : Integer;
begin
  CheckEquals(True, a.Val_64S = b.Val_64S);
  CheckEquals(True, a.Val_64U = b.Val_64U);

  CheckEquals(a.Val_32S,b.Val_32S);
  CheckEquals(a.Val_32U,b.Val_32U);
  
  CheckEquals(a.Val_16S,b.Val_16S);
  CheckEquals(a.Val_16U,b.Val_16U);
  
  CheckEquals(a.Val_8S,b.Val_8S);
  CheckEquals(a.Val_8U,b.Val_8U);
  
  CheckEquals(a.Val_String,b.Val_String);
  CheckEquals(a.Val_Bool,b.Val_Bool);
  CheckEquals(Ord(a.Val_Enum),Ord(b.Val_Enum));
  
  Compare(a.Val_Obj,b.Val_Obj);
  Check(
    ( ( a.Val_StringArray <> nil ) and ( b.Val_StringArray <> nil ) ) or
    ( ( a.Val_StringArray = nil ) and ( b.Val_StringArray = nil ) )
  );
  if ( a.Val_StringArray <> nil ) then begin
    c := a.Val_StringArray.Length;
    for i := 0 to Pred(c) do begin
      CheckEquals(a.Val_StringArray[i],b.Val_StringArray[i]);
    end;
  end;
end;

procedure TTest_TBaseComplexRemotable.Compare(const a, b: TClass_B);
begin
  CheckEquals(a.Val_64S,b.Val_64S);
  CheckEquals(a.Val_64U,b.Val_64U);

  CheckEquals(a.Val_32S,b.Val_32S);
  CheckEquals(a.Val_32U,b.Val_32U);

  CheckEquals(a.Val_16S,b.Val_16S);
  CheckEquals(a.Val_16U,b.Val_16U);

  CheckEquals(a.Val_8S,b.Val_8S);
  CheckEquals(a.Val_8U,b.Val_8U);

  CheckEquals(a.Val_String,b.Val_String);
  CheckEquals(a.Val_Bool,b.Val_Bool);
  CheckEquals(Ord(a.Val_Enum),Ord(b.Val_Enum));
end;

procedure TTest_TBaseComplexRemotable.test_Assign();
const ITER = 100;
var
  a, b : TClass_A;
  i : Integer;
begin
  a := TClass_A.Create();
  try
    b := TClass_A.Create();
    b.Assign(a);
    Compare(a,b);
    
    a.Val_64S := Random(1210);
    a.Val_64U := Random(1210);
    
    a.Val_32S := Random(1210);
    a.Val_32U := Random(1210);

    a.Val_16S := Random(1210);
    a.Val_16U := Random(1210);

    a.Val_8S := Random(123);
    a.Val_8U := Random(123);
    
    a.Val_Enum := teThree;
    a.Val_Bool := True;
    a.Val_String := RandomValue(100);
    
    a.Val_Obj.Val_64S := Random(1210);
    a.Val_Obj.Val_64U := Random(1210);

    a.Val_Obj.Val_32S := Random(1210);
    a.Val_Obj.Val_32U := Random(1210);

    a.Val_Obj.Val_16S := Random(1210);
    a.Val_Obj.Val_16U := Random(1210);

    a.Val_Obj.Val_8S := Random(123);
    a.Val_Obj.Val_8U := Random(123);

    a.Val_Obj.Val_Enum := teTwo;
    a.Val_Obj.Val_Bool := True;
    a.Val_Obj.Val_String := RandomValue(250);
    
    a.Val_StringArray.SetLength(ITER);
    for i := 0 to Pred(ITER) do begin
      a.Val_StringArray[i] := RandomValue(Random(123));
    end;
    
    b.Assign(a);
    Compare(a,b);
  finally
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

procedure TTest_TBaseComplexRemotable.Equal();
const ITER = 100;
var
  a, b : TClass_A;
  cc : TClass_B;
  i : Integer;
begin
  b:= nil;
  cc := nil;
  a := TClass_A.Create();
  try
    b := TClass_A.Create();
    CheckEquals(True,a.Equal(b));
    CheckEquals(True,b.Equal(a));
    CheckEquals(False,a.Equal(nil));
    
    cc := TClass_B.Create();
    CheckEquals(False,a.Equal(cc));
    CheckEquals(False,cc.Equal(a));
    
    a.Val_64S := Random(1210);
    a.Val_64U := Random(1210);
      b.Val_64S := a.Val_64S;
      b.Val_64U := a.Val_64U;

    CheckEquals(True,a.Equal(b));
    CheckEquals(True,b.Equal(a));

    a.Val_32S := Random(1210);
    a.Val_32U := Random(1210);

    a.Val_16S := Random(1210);
    a.Val_16U := Random(1210);

    a.Val_8S := Random(123);
    a.Val_8U := Random(123);

    a.Val_Enum := teThree;
    a.Val_Bool := True;
    a.Val_String := RandomValue(100);

    a.Val_Obj.Val_64S := Random(1210);
    a.Val_Obj.Val_64U := Random(1210);

    a.Val_Obj.Val_32S := Random(1210);
    a.Val_Obj.Val_32U := Random(1210);

    a.Val_Obj.Val_16S := Random(1210);
    a.Val_Obj.Val_16U := Random(1210);

    a.Val_Obj.Val_8S := Random(123);
    a.Val_Obj.Val_8U := Random(123);

    a.Val_Obj.Val_Enum := teTwo;
    a.Val_Obj.Val_Bool := True;
    a.Val_Obj.Val_String := RandomValue(250);

    a.Val_StringArray.SetLength(ITER);
    for i := 0 to Pred(ITER) do begin
      a.Val_StringArray[i] := RandomValue(Random(123));
    end;
    CheckEquals(False,a.Equal(b));
    CheckEquals(False,b.Equal(a));

    b.Assign(a);
    CheckEquals(True,a.Equal(b));
    CheckEquals(True,b.Equal(a));
  finally
    FreeAndNil(cc);
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

{ TClass_A }

constructor TClass_A.Create();
begin
  inherited;
  FVal_Obj := TClass_B.Create();
  FVal_StringArray := TArrayOfStringRemotable.Create();
end;

destructor TClass_A.Destroy();
begin
  FreeAndNil(FVal_StringArray);
  FreeAndNil(FVal_Obj);
  inherited Destroy();
end;

{ TTest_TBaseObjectArrayRemotable }

class function TTest_TBaseObjectArrayRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfClass_A.Create();
end;

class function TTest_TBaseObjectArrayRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(TClass_A);
end;

class procedure TTest_TBaseObjectArrayRemotable.FillRandomItem(const AItem: TBaseRemotable);
var
  a : TClass_A;
  i, c : Integer;
begin
 Randomize();
  a := AItem as TClass_A;

    a.Val_64S := Random(1210);
    a.Val_64U := Random(1210);

    a.Val_32S := Random(1210);
    a.Val_32U := Random(1210);

    a.Val_16S := Random(1210);
    a.Val_16U := Random(1210);

    a.Val_8S := Random(123);
    a.Val_8U := Random(123);

    a.Val_Enum := teThree;
    a.Val_Bool := True;
    a.Val_String := RandomValue(100);

    a.Val_Obj.Val_64S := Random(1210);
    a.Val_Obj.Val_64U := Random(1210);

    a.Val_Obj.Val_32S := Random(1210);
    a.Val_Obj.Val_32U := Random(1210);

    a.Val_Obj.Val_16S := Random(1210);
    a.Val_Obj.Val_16U := Random(1210);

    a.Val_Obj.Val_8S := Random(123);
    a.Val_Obj.Val_8U := Random(123);

    a.Val_Obj.Val_Enum := teTwo;
    a.Val_Obj.Val_Bool := True;
    a.Val_Obj.Val_String := RandomValue(250);

    c := Random(200);
    a.Val_StringArray.SetLength(c);
    if ( c > 0 ) then begin
      for i := 0 to Pred(c) do begin
        a.Val_StringArray[i] := RandomValue(Random(500));
      end;
    end;
end;

procedure TTest_TBaseObjectArrayRemotable.CompareItem(const A, B: TBaseRemotable);
begin
  Compare(A as TClass_A, B as TClass_A);
end;

procedure TTest_TBaseObjectArrayRemotable.Compare(const a, b: TClass_A);
var
  i, c : Integer;
begin
  CheckEquals(a.Val_64S,b.Val_64S);
  CheckEquals(a.Val_64U,b.Val_64U);

  CheckEquals(a.Val_32S,b.Val_32S);
  CheckEquals(a.Val_32U,b.Val_32U);

  CheckEquals(a.Val_16S,b.Val_16S);
  CheckEquals(a.Val_16U,b.Val_16U);

  CheckEquals(a.Val_8S,b.Val_8S);
  CheckEquals(a.Val_8U,b.Val_8U);

  CheckEquals(a.Val_String,b.Val_String);
  CheckEquals(a.Val_Bool,b.Val_Bool);
  CheckEquals(Ord(a.Val_Enum),Ord(b.Val_Enum));

  Compare(a.Val_Obj,b.Val_Obj);
  Check(
    ( ( a.Val_StringArray <> nil ) and ( b.Val_StringArray <> nil ) ) or
    ( ( a.Val_StringArray = nil ) and ( b.Val_StringArray = nil ) )
  );
  if ( a.Val_StringArray <> nil ) then begin
    c := a.Val_StringArray.Length;
    for i := 0 to Pred(c) do begin
      CheckEquals(a.Val_StringArray[i],b.Val_StringArray[i]);
    end;
  end;
end;

procedure TTest_TBaseObjectArrayRemotable.Compare(const a, b: TClass_B);
begin
  CheckEquals(a.Val_64S,b.Val_64S);
  CheckEquals(a.Val_64U,b.Val_64U);

  CheckEquals(a.Val_32S,b.Val_32S);
  CheckEquals(a.Val_32U,b.Val_32U);

  CheckEquals(a.Val_16S,b.Val_16S);
  CheckEquals(a.Val_16U,b.Val_16U);

  CheckEquals(a.Val_8S,b.Val_8S);
  CheckEquals(a.Val_8U,b.Val_8U);

  CheckEquals(a.Val_String,b.Val_String);
  CheckEquals(a.Val_Bool,b.Val_Bool);
  CheckEquals(Ord(a.Val_Enum),Ord(b.Val_Enum));
end;

procedure TTest_TBaseObjectArrayRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TBaseObjectArrayRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := CreateArray() as TBaseObjectArrayRemotable;
  try
    b := CreateArray() as TBaseObjectArrayRemotable;
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(20);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          FillRandomItem(a.Item[k]);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CompareItem(a[k],b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CompareItem(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TBaseObjectArrayRemotable.Equal();
const ITER : Integer = 100;
var
  a, b : TBaseObjectArrayRemotable;
  aa : TClass_A;
  i, j, k : Integer;
begin
  Randomize();
  aa := nil;
  a := CreateArray() as TBaseObjectArrayRemotable;
  try
    b := CreateArray() as TBaseObjectArrayRemotable;
    aa := TClass_A.Create();
    CheckEquals(True,a.Equal(b));
    CheckEquals(True,b.Equal(a));
    CheckEquals(False,a.Equal(nil));
    CheckEquals(False,a.Equal(aa));
    CheckEquals(False,aa.Equal(a));

    for i := 1 to ITER do begin
      Randomize();
      j := Random(20);
      FreeAndNil(a);
      FreeAndNil(b);
      a := CreateArray() as TBaseObjectArrayRemotable;
      b := CreateArray() as TBaseObjectArrayRemotable;
      a.SetLength(j);
      b.SetLength(j);
      if ( j > 0  ) then begin
        TClass_A(b.Item[0]).Val_String := 'azertyqwerty';
        for k := 0 to Pred(j) do begin
          //FillRandomItem(a.Item[k]);
          //FillRandomItem(b.Item[k]);
          //CheckEquals(False,b.Equal(a), '1111');
          //CheckEquals(False,a.Equal(b), '2222');
          b.Item[k].Assign(a.Item[k]);
          CheckEquals(True,a.Equal(b));
          CheckEquals(True,b.Equal(a));
        end;
      end;
    end;
  finally
    FreeAndNil(aa);
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;


{ TTest_TArrayOfBooleanRemotable }

class function TTest_TArrayOfBooleanRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result:= TArrayOfBooleanRemotable.Create();
end;

class function TTest_TArrayOfBooleanRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Boolean);
end;

procedure TTest_TArrayOfBooleanRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfBooleanRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfBooleanRemotable.Create();
  try
    b := TArrayOfBooleanRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := ( ( k mod 3 ) = 0 );
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfBooleanRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfBooleanRemotable;
  i, j, k : Integer;
  a : array of Boolean;
begin
  localObj := TArrayOfBooleanRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := ( ( k mod 5 ) = 1 );
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt8URemotable }

class function TTest_TArrayOfInt8URemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt8URemotable.Create();
end;

class function TTest_TArrayOfInt8URemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Byte);
end;

procedure TTest_TArrayOfInt8URemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfInt8URemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfInt8URemotable.Create();
  try
    b := TArrayOfInt8URemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(Byte) - 1);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfInt8URemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt8URemotable;
  i, j, k : Integer;
  a : array of Byte;
begin
  Randomize();
  localObj := TArrayOfInt8URemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(Byte) - 1 );
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt8SRemotable }

class function TTest_TArrayOfInt8SRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt8SRemotable.Create();
end;

class function TTest_TArrayOfInt8SRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result :=  TypeInfo(ShortInt);
end;

procedure TTest_TArrayOfInt8SRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfInt8SRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfInt8SRemotable.Create();
  try
    b := TArrayOfInt8SRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(ShortInt) - 1)
          else
            a[k] := -Random(High(ShortInt) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfInt8SRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt8SRemotable;
  i, j, k : Integer;
  a : array of ShortInt;
begin
  Randomize();
  localObj := TArrayOfInt8SRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(ShortInt) -1);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt16SRemotable }

class function TTest_TArrayOfInt16SRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt16SRemotable.Create();
end;

class function TTest_TArrayOfInt16SRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(SmallInt);
end;

procedure TTest_TArrayOfInt16SRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfInt16SRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfInt16SRemotable.Create();
  try
    b := TArrayOfInt16SRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(SmallInt) -1)
          else
            a[k] := -Random(High(SmallInt) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfInt16SRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt16SRemotable;
  i, j, k : Integer;
  a : array of SmallInt;
begin
  Randomize();
  localObj := TArrayOfInt16SRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(SmallInt) -1 )
          else
            a[k] := -Random(High(SmallInt) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt16URemotable }

class function TTest_TArrayOfInt16URemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt16URemotable.Create();
end;

class function TTest_TArrayOfInt16URemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Word);
end;

procedure TTest_TArrayOfInt16URemotable.test_Assign();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt16URemotable;
  i, j, k : Integer;
  a : array of Word;
begin
  Randomize();
  localObj := TArrayOfInt16URemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(Word)-1);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

procedure TTest_TArrayOfInt16URemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt16URemotable;
  i, j, k : Integer;
  a : array of Word;
begin
  Randomize();
  localObj := TArrayOfInt16URemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(Word)-1);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt32URemotable }

class function TTest_TArrayOfInt32URemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt32URemotable.Create();
end;

class function TTest_TArrayOfInt32URemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(LongWord);
end;

procedure TTest_TArrayOfInt32URemotable.test_Assign();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt32URemotable;
  i, j, k : Integer;
  a : array of LongWord;
begin
  Randomize();
  localObj := TArrayOfInt32URemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(LongWord)-2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

procedure TTest_TArrayOfInt32URemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt32URemotable;
  i, j, k : Integer;
  a : array of LongWord;
begin
  Randomize();
  localObj := TArrayOfInt32URemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(LongWord)-1);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt32SRemotable }

class function TTest_TArrayOfInt32SRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt32SRemotable.Create();
end;

class function TTest_TArrayOfInt32SRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(LongInt);
end;

procedure TTest_TArrayOfInt32SRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfInt32SRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfInt32SRemotable.Create();
  try
    b := TArrayOfInt32SRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(LongInt) -1)
          else
            a[k] := -Random(High(LongInt) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          CheckEquals(b[k],a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfInt32SRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt32SRemotable;
  i, j, k : Integer;
  a : array of LongInt;
begin
  Randomize();
  localObj := TArrayOfInt32SRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(LongInt) -1 )
          else
            a[k] := -Random(High(LongInt) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          CheckEquals(a[k],localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt64SRemotable }

class function TTest_TArrayOfInt64SRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt64SRemotable.Create();
end;

class function TTest_TArrayOfInt64SRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Int64);
end;

procedure TTest_TArrayOfInt64SRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfInt64SRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfInt64SRemotable.Create();
  try
    b := TArrayOfInt64SRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1)
          else
            a[k] := -Random(High(Int64) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(a[k] = b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(b[k] = a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfInt64SRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt64SRemotable;
  i, j, k : Integer;
  a : array of Int64;
begin
  Randomize();
  localObj := TArrayOfInt64SRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1 )
          else
            a[k] := -Random(High(Int64) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          Check(a[k] = localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfInt64URemotable }

class function TTest_TArrayOfInt64URemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfInt64URemotable.Create();
end;

class function TTest_TArrayOfInt64URemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(QWord);
end;

procedure TTest_TArrayOfInt64URemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfInt64URemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfInt64URemotable.Create();
  try
    b := TArrayOfInt64URemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(Integer) -1);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(a[k] = b[k]);
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(b[k] = a[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfInt64URemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfInt64URemotable;
  i, j, k : Integer;
  a : array of QWord;
begin
  Randomize();
  localObj := TArrayOfInt64URemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          a[k] := Random(High(Integer) -1 );
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          Check(a[k] = localObj[k]);
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfFloatSingleRemotable }

class function TTest_TArrayOfFloatSingleRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfFloatSingleRemotable.Create();
end;

class function TTest_TArrayOfFloatSingleRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Single);
end;

procedure TTest_TArrayOfFloatSingleRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfFloatSingleRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfFloatSingleRemotable.Create();
  try
    b := TArrayOfFloatSingleRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1)
          else
            a[k] := -Random(High(Int64) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k],b[k]));
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(b[k],a[k]));
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfFloatSingleRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfFloatSingleRemotable;
  i, j, k : Integer;
  a : array of Single;
begin
  Randomize();
  localObj := TArrayOfFloatSingleRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1 )
          else
            a[k] := -Random(High(Int64) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k], localObj[k]));
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfFloatDoubleRemotable }

class function TTest_TArrayOfFloatDoubleRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfFloatDoubleRemotable.Create();
end;

class function TTest_TArrayOfFloatDoubleRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Double);
end;

procedure TTest_TArrayOfFloatDoubleRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfFloatDoubleRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfFloatDoubleRemotable.Create();
  try
    b := TArrayOfFloatDoubleRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1)
          else
            a[k] := -Random(High(Int64) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k],b[k]));
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(b[k],a[k]));
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfFloatDoubleRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfFloatDoubleRemotable;
  i, j, k : Integer;
  a : array of Double;
begin
  Randomize();
  localObj := TArrayOfFloatDoubleRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1 )
          else
            a[k] := -Random(High(Int64) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k], localObj[k]));
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfFloatExtendedRemotable }

class function TTest_TArrayOfFloatExtendedRemotable.CreateArray(): TBaseArrayRemotable;
begin
  Result := TArrayOfFloatExtendedRemotable.Create();
end;

class function TTest_TArrayOfFloatExtendedRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Extended);
end;

procedure TTest_TArrayOfFloatExtendedRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfFloatExtendedRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfFloatExtendedRemotable.Create();
  try
    b := TArrayOfFloatExtendedRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1)
          else
            a[k] := -Random(High(Int64) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k],b[k]));
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(b[k],a[k]));
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfFloatExtendedRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfFloatExtendedRemotable;
  i, j, k : Integer;
  a : array of Extended;
begin
  Randomize();
  localObj := TArrayOfFloatExtendedRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Int64) -1 )
          else
            a[k] := -Random(High(Int64) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k], localObj[k]));
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TArrayOfFloatCurrencyRemotable }

class function TTest_TArrayOfFloatCurrencyRemotable.CreateArray( ): TBaseArrayRemotable;
begin
  Result := TArrayOfFloatCurrencyRemotable.Create();
end;

class function TTest_TArrayOfFloatCurrencyRemotable.GetTypeInfo(): PTypeInfo;
begin
  Result := TypeInfo(Currency);
end;

procedure TTest_TArrayOfFloatCurrencyRemotable.test_Assign();
const ITER : Integer = 100;
var
  a, b : TArrayOfFloatCurrencyRemotable;
  i, j, k : Integer;
begin
  Randomize();
  a := TArrayOfFloatCurrencyRemotable.Create();
  try
    b := TArrayOfFloatCurrencyRemotable.Create();
    a.Assign(nil);

    for i := 1 to ITER do begin
      j := Random(ITER);
      a.SetLength(j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Integer) -1)
          else
            a[k] := -Random(High(Integer) - 2);
        end;
      end;
      b.Assign(a);
      CheckEquals(a.Length,b.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k],b[k],0.0001));
        end;
      end;

      a.SetLength(0);
      a.Assign(b);
      CheckEquals(b.Length,a.Length, 'Length');
      if ( j > 0 ) then begin
        for k := 0 to Pred(j) do begin
          Check(SameValue(b[k],a[k],0.0001));
        end;
      end;
    end;
  finally
    FreeAndNil(a);
    FreeAndNil(b);
  end;
end;

procedure TTest_TArrayOfFloatCurrencyRemotable.GetItemAndSetItem();
const ITER : Integer = 100;
var
  localObj : TArrayOfFloatCurrencyRemotable;
  i, j, k : Integer;
  a : array of Currency;
begin
  Randomize();
  localObj := TArrayOfFloatCurrencyRemotable.Create() ;
  try
    for i := 1 to ITER do begin
      j := Random(ITER);
      SetLength(a,j);
      if ( j > 0  ) then begin
        for k := 0 to Pred(j) do begin
          if ( ( k mod 2 ) = 0 ) then
            a[k] := Random(High(Integer) -1 )
          else
            a[k] := -Random(High(Integer) -2);
        end;

        localObj.SetLength(j);
        for k := 0 to Pred(j) do begin
          localObj[k] := a[k];
        end;
        for k := 0 to Pred(j) do begin
          Check(SameValue(a[k], localObj[k], 0.0001));
        end;
      end;
    end;
  finally
    FreeAndNil(localObj);
  end;
end;

{ TTest_TDateRemotable }

procedure TTest_TDateRemotable.FormatDate();
const
  sDATE_1 = '1976-10-12T23:34:56';
  sDATE_2 = '0987-06-12T20:34:56';
var
  d : TDateTime;
begin
  //'-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?
  d := EncodeDate(1976,10,12) + EncodeTime(23,34,56,0);
  CheckEquals(sDATE_1, Copy(TDateRemotable.FormatDate(d),1,Length(sDATE_1)));

  d := EncodeDate(987,06,12) - EncodeTime(20,34,56,0);
  CheckEquals(sDATE_2, Copy(TDateRemotable.FormatDate(d),1,Length(sDATE_2)));
end;

procedure TTest_TDateRemotable.ParseDate();
const sDATE = '1976-10-12T23:34:56';
var
  s : string;
  objd : TDateRemotable;
  d : TDateTime;
  y,m,dy : Word;
  hh,mn,ss, ssss : Word;
begin
  //'-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?
  s := '1976-10-12T23:34:56';
  d := TDateRemotable.ParseDate(s);
  DecodeDate(d,y,m,dy);
    CheckEquals(y,1976,'Year');
    CheckEquals(m,10,'Month');
    CheckEquals(dy,12,'Day');

  DecodeTime(d,hh,mn,ss,ssss);
    CheckEquals(hh,23,'Hour');
    CheckEquals(mn,34,'Minute');
    CheckEquals(ss,56,'Second');

  objd := TDateRemotable.Create();
  try
    objd.AsDate := d;
    CheckEquals(objd.Year,1976,'Year');
    CheckEquals(objd.Month,10,'Month');
    CheckEquals(objd.Day,12,'Day');
    CheckEquals(objd.Hour,23,'Hour');
    CheckEquals(objd.Minute,34,'Minute');
    CheckEquals(objd.Second,56,'Second');
  finally
    FreeAndNil(objd);
  end;
end;

procedure TTest_TDateRemotable.Assign();
var
  a, b : TDateRemotable;
begin
  b := nil;
  a := TDateRemotable.Create();
  try
    b := TDateRemotable.Create();
    Check(IsZero(a.AsDate - b.AsDate));

    a.AsDate := Now();
    b.Assign(a);
    Check(IsZero(a.AsDate - b.AsDate));

    a.AsDate := Now() + 1;
    a.Assign(b);
    Check(IsZero(a.AsDate - b.AsDate));
  finally
    b.Free();
    a.Free();
  end;
end;

procedure TTest_TDateRemotable.Equal();
var
  a, b : TDateRemotable;
  c : TClass_A;
begin
  c := nil;
  b := nil;
  a := TDateRemotable.Create();
  try
    b := TDateRemotable.Create();
    c := TClass_A.Create();
    
    CheckEquals(False,a.Equal(nil));
    CheckEquals(False,a.Equal(c));
    
    a.AsDate := Now();
    b.AsDate := a.AsDate;
    CheckEquals(True,a.Equal(b));
    CheckEquals(True,b.Equal(a));

    a.AsDate := a.AsDate + 1;
    CheckEquals(False,a.Equal(b));
    CheckEquals(False,b.Equal(a));
  finally
    c.Free();
    b.Free();
    a.Free();
  end;
end;

procedure TTest_TDateRemotable.FormatDate_ZERO();
const sDATE = '1899-12-30T00:00:00';
var
  d : TDateTime;
begin
  //'-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?
  d := 0;
  CheckEquals(sDATE, Copy(TDateRemotable.FormatDate(d),1,Length(sDATE)));
end;

{ TTest_TDurationRemotable }

procedure TTest_TDurationRemotable.FormatDate();
begin
  Fail('Write me!');
end;

procedure TTest_TDurationRemotable.ParseDate();
begin
  Fail('Write me!');
end;

{ TTest_TTimeRemotable }

procedure TTest_TTimeRemotable.FormatDate();
begin
  Fail('Write me!');
end;

procedure TTest_TTimeRemotable.ParseDate();
begin
  Fail('Write me!');
end;

{ TTest_TStringBufferRemotable }

procedure TTest_TStringBufferRemotable.test_Assign();
const ITER = 100;
var
  i : Integer;
  a, b : TStringBufferRemotable;
begin
  b := nil;
  a := TStringBufferRemotable.Create();
  try
    b := TStringBufferRemotable.Create();
    for i := 1 to ITER do begin
      a.Data := RandomValue(Random(500));
      b.Assign(a);
      CheckEquals(a.Data, b.Data);
    end;
  finally
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

procedure TTest_TStringBufferRemotable.Equal();
const ITER = 100;
var
  i : Integer;
  a, b : TStringBufferRemotable;
  c : TClass_A;
begin
  c := nil;
  b := nil;
  a := TStringBufferRemotable.Create();
  try
    b := TStringBufferRemotable.Create();
    CheckEquals(False, a.Equal(nil));
    c := TClass_A.Create();
    CheckEquals(False, a.Equal(c));
    a.Data := 'wst';
    b.Data := 'azerty';
    CheckEquals(False, a.Equal(b));
    CheckEquals(False, b.Equal(a));

    for i := 1 to ITER do begin
      a.Data := RandomValue(Random(500));
      b.Data := a.Data;
      CheckEquals(True, a.Equal(b));
      CheckEquals(True, b.Equal(a));
    end;
  finally
    FreeAndNil(c);
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

{ TTest_TBase64StringRemotable }

procedure TTest_TBase64StringRemotable.test_Assign();
const ITER = 100;
var
  i : Integer;
  a, b : TBase64StringRemotable;
begin
  b := nil;
  a := TBase64StringRemotable.Create();
  try
    b := TBase64StringRemotable.Create();
    for i := 1 to ITER do begin
      a.BinaryData := RandomValue(Random(500));
      b.Assign(a);
      CheckEquals(a.BinaryData, b.BinaryData);
      CheckEquals(a.EncodedString, b.EncodedString);
    end;
  finally
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

procedure TTest_TBase64StringRemotable.Equal();
const ITER = 100;
var
  i : Integer;
  a, b : TBase64StringRemotable;
  c : TClass_A;
begin
  c := nil;
  b := nil;
  a := TBase64StringRemotable.Create();
  try
    b := TBase64StringRemotable.Create();
    CheckEquals(False, a.Equal(nil));
    c := TClass_A.Create();
    CheckEquals(False, a.Equal(c));
    a.BinaryData := 'wst';
    b.BinaryData := 'azerty';
    CheckEquals(False, a.Equal(b));
    CheckEquals(False, b.Equal(a));

    for i := 1 to ITER do begin
      a.BinaryData := RandomValue(Random(500));
      b.BinaryData := a.BinaryData;
      CheckEquals(True, a.Equal(b));
      CheckEquals(True, b.Equal(a));
    end;
  finally
    FreeAndNil(c);
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

procedure TTest_TBase64StringRemotable.SetBinaryData();
const ITER = 100;
var
  i : Integer;
  a : TBase64StringRemotable;
  s, es : string;
begin
  a := TBase64StringRemotable.Create();
  try
    s := ''; es := Base64Encode(s);
    a.BinaryData := s;
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);

    for i := 1 to ITER do begin
      s := RandomValue(Random(500)); es := Base64Encode(s);
      a.BinaryData := s;
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
    end;
  finally
    FreeAndNil(a);
  end;
end;

procedure TTest_TBase64StringRemotable.SetEncodedString();
const ITER = 100;
var
  i : Integer;
  a : TBase64StringRemotable;
  s, es : string;
begin
  a := TBase64StringRemotable.Create();
  try
    s := ''; es := Base64Encode(s);
    a.EncodedString := es;
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);

    for i := 1 to ITER do begin
      s := RandomValue(Random(500)); es := Base64Encode(s);
      a.EncodedString := es;
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
    end;
  finally
    FreeAndNil(a);
  end;
end;

{ TTest_TBase64StringExtRemotable }

procedure TTest_TBase64StringExtRemotable.Equal();
const ITER = 100;
var
  i : Integer;
  a, b : TBase64StringExtRemotable;
  c : TClass_A;
begin
  c := nil;
  b := nil;
  a := TBase64StringExtRemotable.Create();
  try
    b := TBase64StringExtRemotable.Create();
    CheckEquals(False, a.Equal(nil));
    c := TClass_A.Create();
    CheckEquals(False, a.Equal(c));
    a.BinaryData := 'wst';
    b.BinaryData := 'azerty';
    CheckEquals(False, a.Equal(b));
    CheckEquals(False, b.Equal(a));

    for i := 1 to ITER do begin
      a.BinaryData := RandomValue(Random(500));
      b.BinaryData := a.BinaryData;
      CheckEquals(True, a.Equal(b));
      CheckEquals(True, b.Equal(a));
    end;
  finally
    FreeAndNil(c);
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

procedure TTest_TBase64StringExtRemotable.SetBinaryData();
const ITER = 100;
var
  i : Integer;
  a : TBase64StringExtRemotable;
  s, es : string;
begin
  a := TBase64StringExtRemotable.Create();
  try
    s := ''; es := Base64Encode(s);
    a.BinaryData := s;
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);

    for i := 1 to ITER do begin
      s := RandomValue(Random(500)); es := Base64Encode(s);
      a.BinaryData := s;
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
    end;
  finally
    FreeAndNil(a);
  end;
end;

procedure TTest_TBase64StringExtRemotable.SetEncodedString();
const ITER = 100;
var
  i : Integer;
  a : TBase64StringExtRemotable;
  s, es : string;
begin
  a := TBase64StringExtRemotable.Create();
  try
    s := ''; es := Base64Encode(s);
    a.EncodedString := es;
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);
    CheckEquals(s,a.BinaryData);
    CheckEquals(es,a.EncodedString);

    for i := 1 to ITER do begin
      s := RandomValue(Random(500)); es := Base64Encode(s);
      a.EncodedString := es;
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
      CheckEquals(s,a.BinaryData);
      CheckEquals(es,a.EncodedString);
    end;
  finally
    FreeAndNil(a);
  end;
end;

procedure TTest_TBase64StringExtRemotable.test_Assign();
const ITER = 100;
var
  i : Integer;
  a, b : TBase64StringExtRemotable;
begin
  b := nil;
  a := TBase64StringExtRemotable.Create();
  try
    b := TBase64StringExtRemotable.Create();
    for i := 1 to ITER do begin
      a.BinaryData := RandomValue(Random(500));
      b.Assign(a);
      CheckEquals(a.BinaryData, b.BinaryData);
      CheckEquals(a.EncodedString, b.EncodedString);
    end;
  finally
    FreeAndNil(b);
    FreeAndNil(a);
  end;
end;

initialization
  RegisterTest('Support',TTest_TBaseComplexRemotable.Suite);
  RegisterTest('Support',TTest_TStringBufferRemotable.Suite);
  RegisterTest('Support-Date',TTest_TDateRemotable.Suite);
  RegisterTest('Support-Date',TTest_TDurationRemotable.Suite);
  RegisterTest('Support-Date',TTest_TTimeRemotable.Suite);
  
  RegisterTest('Support',TTest_TArrayOfStringRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfBooleanRemotable.Suite);
  
  RegisterTest('Support',TTest_TArrayOfInt8URemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt8SRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt16SRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt16URemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt32URemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt32SRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt64SRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfInt64URemotable.Suite);
  
  RegisterTest('Support',TTest_TArrayOfFloatSingleRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfFloatDoubleRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfFloatExtendedRemotable.Suite);
  RegisterTest('Support',TTest_TArrayOfFloatCurrencyRemotable.Suite);
  
  RegisterTest('Support',TTest_TBaseObjectArrayRemotable.Suite);

  RegisterTest('Support',TTest_TBase64StringRemotable.Suite);
  RegisterTest('Support',TTest_TBase64StringExtRemotable.Suite);
  
end.