RealICQClient/Backup/ZMQTest/delphizmq-master/tests/Testzmqapi.pas

unit Testzmqapi;
{

  Delphi DUnit Test Case
  ----------------------
  This unit contains a skeleton test case class generated by the Test Case Wizard.
  Modify the generated code to correctly setup and call the methods from the unit
  being tested.

}

interface

uses
  TestFramework, Classes, zmqapi, zmqcpp;
type

  // Test methods for class TZMQSocket

  TestTZMQSocket = class(TTestCase)
  strict private
    context: TZMQContext;
    FZMQSocket: TZMQSocket;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestgetSocketType;
    procedure TestgetrcvMore;
    procedure TestgetHWM;
    procedure TestgetRcvTimeout;
    procedure TestgetSndTimeout;
    procedure TestgetSwap;
    procedure TestgetAffinity;
    procedure TestgetIdentity;
    procedure TestgetRate;
    procedure TestgetRecoveryIvl;
    procedure TestgetRecoveryIvlMSec;
    procedure TestgetMCastLoop;
    procedure TestgetSndBuf;
    procedure TestgetRcvBuf;
    procedure TestgetLinger;
    procedure TestgetReconnectIvl;
    procedure TestgetReconnectIvlMax;
    procedure TestgetBacklog;
    procedure TestgetFD;
    procedure TestgetEvents;
    procedure TestsetHWM;
    procedure TestsetRcvTimeout;
    procedure TestsetSndTimeout;
    procedure TestsetSwap;
    procedure TestsetAffinity;
    procedure TestsetIdentity;
    procedure TestsetRate;
    procedure TestsetRecoveryIvl;
    procedure TestsetRecoveryIvlMSec;
    procedure TestsetMCastLoop;
    procedure TestsetSndBuf;
    procedure TestsetRcvBuf;
    procedure TestsetLinger;
    procedure TestsetReconnectIvl;
    procedure TestsetReconnectIvlMax;
    procedure TestsetBacklog;
    procedure TestSubscribe;
    procedure TestunSubscribe;
    procedure Testsend;
    procedure Testsend1;
    procedure Testsend2;
    procedure Testsend3;
    procedure Testrecv;
    procedure Testrecv1;
    procedure Testrecv2;
    procedure Testrecv3;
  end;

implementation

uses
  SysUtils
  ;
procedure TestTZMQSocket.SetUp;
begin
  context := TZMQContext.Create(1);
end;

procedure TestTZMQSocket.TearDown;
begin
  context.Free;
end;

procedure TestTZMQSocket.TestgetSocketType;
var
  ReturnValue: TZMQSocketType;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getSocketType;
      Check( ReturnValue = st );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetrcvMore;
var
  ReturnValue: Boolean;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getrcvMore;
      CheckEquals( False, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetHWM;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getHWM;
      CheckEquals( 0, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetRcvTimeout;
var
  ReturnValue: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getRcvTimeout;
      CheckEquals( -1, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetSndTimeout;
var
  ReturnValue: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getSndTimeout;
      CheckEquals( -1, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetSwap;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getSwap;
      CheckEquals( 0, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetAffinity;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getAffinity;
      CheckEquals( 0, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetIdentity;
var
  ReturnValue: ShortString;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getIdentity;
      CheckEquals( '', ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetRate;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getRate;
      CheckEquals( 100, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetRecoveryIvl;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getRecoveryIvl;
      CheckEquals( 10, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetRecoveryIvlMSec;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getRecoveryIvlMSec;
      CheckEquals( -1, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetMCastLoop;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getMCastLoop;
      CheckEquals( 1, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetSndBuf;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getSndBuf;
      CheckEquals( 0, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetRcvBuf;
var
  ReturnValue: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getRcvBuf;
      CheckEquals( 0, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetLinger;
var
  ReturnValue: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getLinger;
      CheckEquals( -1, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetReconnectIvl;
var
  ReturnValue: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getReconnectIvl;
      CheckEquals( 100, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetReconnectIvlMax;
var
  ReturnValue: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getReconnectIvlMax;
      CheckEquals( 0, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetBacklog;
var
  ReturnValue: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getBacklog;
      CheckEquals( 100, ReturnValue );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetFD;
var
  ReturnValue: Pointer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getFD;
      Check( Assigned( ReturnValue ) );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestgetEvents;
var
  ReturnValue: TZMQPollEvents;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      ReturnValue := FZMQSocket.getEvents;
      CheckEquals( True, ReturnValue = [], ' For socket type: ' + IntToStr( Ord( st ) ) );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestsetHWM;
var
  Value: Int64;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      Value := 42;
      FZMQSocket.setHWM( Value );
      CheckEquals( 42, FZMQSocket.getHWM );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestsetRcvTimeout;
var
  Value: Integer;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      Value := 42;
      FZMQSocket.setRcvTimeout( Value );
      FZMQSocket.bind('tcp://*:5555');
      CheckEquals( 42, FZMQSocket.getRcvTimeout );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestsetSndTimeout;
var
  Value: Integer;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setSndTimeout(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetSwap;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setSwap(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetAffinity;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setAffinity(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetIdentity;
var
  Value: ShortString;
  st: TZMQSocketType;
begin
  for st := Low( TZMQSocketType ) to High( TZMQSocketType ) do
  begin
    FZMQSocket := TZMQSocket.Create( context, st );
    try
      Value := 'testIdentity';
      FZMQSocket.setIdentity( Value );
      CheckEquals( 'testIdentity', FZMQSocket.getIdentity );
    finally
      FZMQSocket.Free;
    end;
  end;
end;

procedure TestTZMQSocket.TestsetRate;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setRate(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetRecoveryIvl;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setRecoveryIvl(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetRecoveryIvlMSec;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setRecoveryIvlMSec(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetMCastLoop;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setMCastLoop(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetSndBuf;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setSndBuf(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetRcvBuf;
var
  Value: Int64;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setRcvBuf(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetLinger;
var
  Value: Integer;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setLinger(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetReconnectIvl;
var
  Value: Integer;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setReconnectIvl(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetReconnectIvlMax;
var
  Value: Integer;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setReconnectIvlMax(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestsetBacklog;
var
  Value: Integer;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.setBacklog(Value);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestSubscribe;
var
  filter: string;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.Subscribe(filter);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.TestunSubscribe;
var
  filter: string;
begin
{  FZMQSocket := TZMQSocket.Create( context, st );
  try
  // TODO: Setup method call parameters
  FZMQSocket.unSubscribe(filter);
  // TODO: Validate method results
  finally
    FZMQSocket.Free;
  end;
}end;

procedure TestTZMQSocket.Testsend;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: TZMQMessage;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.send(msg, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testsend1;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: String;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.send(msg, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testsend2;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: TStrings;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.send(msg, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testsend3;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: string;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.send(msg, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testrecv;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: TZMQMessage;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.recv(msg, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testrecv1;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msgs: TZMQMessageList;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.recv(msgs, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testrecv2;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: TStrings;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.recv(msg, flags);
  // TODO: Validate method results
end;

procedure TestTZMQSocket.Testrecv3;
var
  ReturnValue: Boolean;
  flags: TZMQRecvSendFlags;
  msg: string;
begin
  // TODO: Setup method call parameters
  ReturnValue := FZMQSocket.recv(msg, flags);
  // TODO: Validate method results
end;

initialization
  // Register any test cases with the test runner
  RegisterTest(TestTZMQSocket.Suite);
end.