[Instantobjects-cvscommit] Source/Tests TestInstantDateTime.pas,NONE,1.1 TestInstantString.pas,NONE,

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/instantobjects/Source/Tests
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv356

Modified Files:
	TestIO.dpr TestInstantInteger.pas 
Added Files:
	TestInstantDateTime.pas TestInstantString.pas 
Log Message:
Add tests for TInstantString and TInstantDateTime classes.
Minor edits to TInstantInteger class tests.

--- NEW FILE: TestInstantDateTime.pas ---
unit TestInstantDateTime;

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantDateTime
  TestTInstantDateTime = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantDateTime: TInstantDateTime;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAsBoolean;
    procedure TestAsCurrency;
    procedure TestAsDateTime;
    procedure TestAsFloat;
    procedure TestAsInteger;
    procedure TestAsObject;
    procedure TestAssign;
    procedure TestAsString;
    procedure TestAsVariant;
    procedure TestChange;
    procedure TestCheckHasMetadata;
    procedure TestDisplayText;
    procedure TestIsDefault;
    procedure TestIsIndexed;
    procedure TestIsMandatory;
    procedure TestIsRequired;
    procedure TestMetadata;
    procedure TestName;
    procedure TestOwner;
    procedure TestReset;
    procedure TestValue;
  end;

implementation

uses SysUtils, testregistry, InstantClasses;

procedure TestTInstantDateTime.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantDateTime;
  FAttrMetadata.Name := 'AttrMetadataName';
  FInstantDateTime := TInstantDateTime.Create(FOwner, FAttrMetadata);
  FInstantDateTime.Value := 100.5;
end;

procedure TestTInstantDateTime.TearDown;
begin
  FreeAndNil(FInstantDateTime);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

procedure TestTInstantDateTime.TestAsBoolean;
begin
  try
    FInstantDateTime.AsBoolean := True;
    Fail('Exception was not thrown for Set AsBoolean!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
  try
    FInstantDateTime.AsBoolean;
    Fail('Exception was not thrown for Get AsBoolean!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantDateTime.TestAsCurrency;
begin
  try
    FInstantDateTime.AsCurrency := 20.5;
    Fail('Exception was not thrown for Set AsCurrency!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
  try
    FInstantDateTime.AsCurrency;
    Fail('Exception was not thrown for Get AsCurrency!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantDateTime.TestAsDateTime;
begin
  FInstantDateTime.AsDateTime := 12.45;
  AssertEquals('Set AsDateTime is incorrect!', 12.45,
    FInstantDateTime.Value);
  AssertEquals('Get AsDateTime is incorrect!', 12.45,
    FInstantDateTime.AsDateTime);
end;

procedure TestTInstantDateTime.TestAsFloat;
begin
  try
    FInstantDateTime.AsFloat := 20.5;
    Fail('Exception was not thrown for Set AsFloat!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
  try
    FInstantDateTime.AsFloat;
    Fail('Exception was not thrown for Get AsFloat!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantDateTime.TestAsInteger;
begin
  try
    FInstantDateTime.AsInteger := 20;
    Fail('Exception was not thrown for Set AsInteger!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
  try
    FInstantDateTime.AsInteger;
    Fail('Exception was not thrown for Get AsInteger!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantDateTime.TestAsObject;
begin
  try
    FInstantDateTime.AsObject := TInstantObject.Create(FConn);
    Fail('Exception was not thrown for Set AsObject!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
  try
    FInstantDateTime.AsObject;
    Fail('Exception was not thrown for Get AsObject!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantDateTime.TestAssign;
var
  vSource: TInstantDateTime;
begin
  AssertEquals('String value is incorrect!', 100.5,
    FInstantDateTime.Value);

  vSource := TInstantDateTime.Create;
  try
    VSource.Value := 115.3;
    FInstantDateTime.Assign(vSource);
    AssertEquals('String value is incorrect!', 115.3,
      FInstantDateTime.Value);
  finally
    vSource.Free;
  end;
end;

procedure TestTInstantDateTime.TestAsString;
begin
  FInstantDateTime.AsString := DateTimeToStr(14.5);
  AssertEquals('Set AsString is incorrect!', 14.5,
    FInstantDateTime.Value);
  AssertEquals('Get AsString is incorrect!', DateTimeToStr(14.5),
    FInstantDateTime.AsString);
end;

procedure TestTInstantDateTime.TestAsVariant;
begin                                           
  FInstantDateTime.AsVariant := 150.6;
  AssertEquals('Set AsVariant is incorrect!', 150.6,
    FInstantDateTime.Value);
  AssertEquals('Get AsVariant is incorrect!', 150.6,
    FInstantDateTime.AsVariant);
end;

procedure TestTInstantDateTime.TestChange;
begin
  AssertTrue('IsChanged is false!', FInstantDateTime.IsChanged);
  FInstantDateTime.UnChanged;
  AssertFalse('IsChanged is true!', FInstantDateTime.IsChanged);
  FInstantDateTime.Value := FInstantDateTime.Value + 30;
  AssertTrue('IsChanged is false!', FInstantDateTime.IsChanged);
  FInstantDateTime.UnChanged;
  AssertFalse('IsChanged is true!', FInstantDateTime.IsChanged);
  FInstantDateTime.Changed;
  AssertTrue('IsChanged is false!', FInstantDateTime.IsChanged);
end;

procedure TestTInstantDateTime.TestCheckHasMetadata;
begin
  try
    FInstantDateTime.CheckHasMetadata;
  except
    Fail('CheckHasMetadata failed!');
  end;

  FInstantDateTime.Metadata := nil;
  AssertException(EInstantError, FInstantDateTime.CheckHasMetadata);
end;

procedure TestTInstantDateTime.TestDisplayText;
var
  vDateTimeStr: string;
begin
  AssertEquals('DisplayText is incorrect!', FInstantDateTime.AsString,
    FInstantDateTime.DisplayText);

  DateTimeToString(vDateTimeStr, 'yyyymmddhhnnsszzz', FInstantDateTime.Value);
  FInstantDateTime.Metadata.EditMask := 'yyyymmddhhnnsszzz';
  AssertEquals('DisplayText is incorrect!', vDateTimeStr,
  FInstantDateTime.DisplayText);

  FInstantDateTime.Value := 113.8;
  DateTimeToString(vDateTimeStr, 'dd mmm yyyy hh:nn:ss ampm',
    FInstantDateTime.Value);
  FInstantDateTime.Metadata.EditMask := 'dd mmm yyyy hh:nn:ss ampm';
  AssertEquals('DisplayText is incorrect!', vDateTimeStr,
    FInstantDateTime.DisplayText);
end;

procedure TestTInstantDateTime.TestIsDefault;
begin
  AssertFalse('Value is default!', FInstantDateTime.IsDefault);

  FInstantDateTime.Value := 0;
  AssertTrue('Value is not default!', FInstantDateTime.IsDefault);
end;

procedure TestTInstantDateTime.TestIsIndexed;
begin
  AssertFalse('Attribute is indexed!', FInstantDateTime.IsIndexed);

  FInstantDateTime.Metadata.IsIndexed := True;
  AssertTrue('Attribute is not indexed!', FInstantDateTime.IsIndexed);
end;

procedure TestTInstantDateTime.TestIsMandatory;
begin
  AssertFalse('Attribute is Mandatory!', FInstantDateTime.IsMandatory);

  FInstantDateTime.Metadata.IsIndexed := True;
  AssertTrue('Attribute is not Mandatory!', FInstantDateTime.IsMandatory);
  FInstantDateTime.Metadata.IsRequired := True;
  AssertTrue('Attribute is not Mandatory!', FInstantDateTime.IsMandatory);
  FInstantDateTime.Metadata.IsIndexed := False;
  AssertTrue('Attribute is not Mandatory!', FInstantDateTime.IsMandatory);
end;

procedure TestTInstantDateTime.TestIsRequired;
begin
  AssertFalse('Attribute is required!', FInstantDateTime.IsRequired);

  FInstantDateTime.Metadata.IsRequired := True;
  AssertTrue('Attribute is not required!', FInstantDateTime.IsRequired);
end;

procedure TestTInstantDateTime.TestMetadata;
begin
  AssertNotNull('Metadata is nil!', FInstantDateTime.Metadata);
  AssertEquals('Metdata name is incorrect!', 'AttrMetadataName',
    FInstantDateTime.Metadata.Name);

  FInstantDateTime.Metadata := nil;
  AssertNull('Metadata is not nil!', FInstantDateTime.Metadata);
  FInstantDateTime.Reset;

  FInstantDateTime.Metadata := FAttrMetadata;
  AssertNotNull('Metadata is nil!', FInstantDateTime.Metadata);
  AssertEquals('Metdata name is incorrect!', 'AttrMetadataName',
    FInstantDateTime.Metadata.Name);
end;

procedure TestTInstantDateTime.TestName;
begin
  AssertEquals('Attribute name is incorrect!', 'AttrMetadataName',
    FInstantDateTime.Name);
end;

procedure TestTInstantDateTime.TestOwner;
begin
  AssertSame('Owner is incorrect!', FOwner, FInstantDateTime.Owner);
end;

procedure TestTInstantDateTime.TestReset;
var
  vDateTimeStr: string;
begin
  AssertNotNull('Metadata is nil!', FInstantDateTime.Metadata);
  // Metadata.DefaultValue is '';
  FInstantDateTime.Reset;
  AssertEquals('Reset value is incorrect!', 0, FInstantDateTime.Value);

  DateTimeToString(vDateTimeStr, 'yyyymmddhhnnsszzz', 100.5);
  FInstantDateTime.Metadata.DefaultValue := vDateTimeStr;
  FInstantDateTime.Reset;
  AssertEquals('Reset value is incorrect!', 100.5, FInstantDateTime.Value);

  FInstantDateTime.Metadata := nil;
  AssertNull('Metadata is not nil!', FInstantDateTime.Metadata);
  FInstantDateTime.Reset;
  AssertEquals('Reset value is incorrect!', 0, FInstantDateTime.Value);
end;

procedure TestTInstantDateTime.TestValue;
begin
  AssertEquals('Value is incorrect!', 100.5, FInstantDateTime.Value);
  FInstantDateTime.Value := 151.3;
  AssertEquals('Value is incorrect!', 151.3, FInstantDateTime.Value);
end;

initialization
  // Register any test cases with the test runner
{$IFNDEF CURR_TESTS}
  RegisterTests([TestTInstantDateTime]);
{$ENDIF}

end.

--- NEW FILE: TestInstantString.pas ---
unit TestInstantString;

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantString
  TestTInstantString = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantString: TInstantString;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAsBoolean;
    procedure TestAsCurrency;
    procedure TestAsDateTime;
    procedure TestAsFloat;
    procedure TestAsInteger;
    procedure TestAsObject;
    procedure TestAssign;
    procedure TestAsString;
    procedure TestAsVariant;
    procedure TestChange;
    procedure TestCheckHasMetadata;
    procedure TestDisplayText;
    procedure TestIsDefault;
    procedure TestIsIndexed;
    procedure TestIsMandatory;
    procedure TestIsRequired;
    procedure TestMetadata;
    procedure TestName;
    procedure TestOwner;
    procedure TestReset;
    procedure TestValue;
  end;

implementation

uses SysUtils, testregistry, InstantClasses;

procedure TestTInstantString.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantString;
  FAttrMetadata.Name := 'AttrMetadataName';
  FInstantString := TInstantString.Create(FOwner, FAttrMetadata);
  FInstantString.Value := 'StringValue';
end;

procedure TestTInstantString.TearDown;
begin
  FreeAndNil(FInstantString);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

procedure TestTInstantString.TestAsBoolean;
begin
  FInstantString.AsBoolean := True;
  AssertEquals('Set AsBoolean is incorrect!', 'True', FInstantString.Value);
  AssertTrue('Get AsBoolean is false!', FInstantString.AsBoolean);

  FInstantString.AsBoolean := False;
  AssertEquals('Set AsBoolean is incorrect!', 'False', FInstantString.Value);
  AssertFalse('Get AsBoolean is true!', FInstantString.AsBoolean);
end;

procedure TestTInstantString.TestAsCurrency;
begin
  FInstantString.AsCurrency := 23.45;
  AssertEquals('Set AsCurrency is incorrect!', '23.45', FInstantString.Value);
  AssertEquals('Get AsCurrency is incorrect!', 23.45,
    FInstantString.AsCurrency);
end;

procedure TestTInstantString.TestAsDateTime;
begin
  FInstantString.AsDateTime := 12.45;
  AssertEquals('Set AsDateTime is incorrect!', DateTimeToStr(12.45),
    FInstantString.Value);
  AssertEquals('Get AsDateTime is incorrect!', 12.45,
    FInstantString.AsDateTime);
end;

procedure TestTInstantString.TestAsFloat;
begin
  FInstantString.AsFloat := 89.45;
  AssertEquals('Set AsFloat is incorrect!', '89.45', FInstantString.Value);
  AssertEquals('Get AsFloat is incorrect!', 89.45, FInstantString.AsFloat);
end;

procedure TestTInstantString.TestAsInteger;
begin
  FInstantString.AsInteger := 100;
  AssertEquals('Set AsInteger is incorrect!', '100', FInstantString.Value);
  AssertEquals('Get AsInteger is incorrect!', 100, FInstantString.AsInteger);
end;

procedure TestTInstantString.TestAsObject;
begin
  try
    FInstantString.AsObject := TInstantObject.Create(FConn);
    Fail('Exception was not thrown for Set AsObject!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
  try
    FInstantString.AsObject;
    Fail('Exception was not thrown for Get AsObject!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantString.TestAssign;
var
  vSource: TInstantString;
begin
  AssertEquals('String value is incorrect!', 'StringValue',
    FInstantString.Value);

  vSource := TInstantString.Create;
  try
    VSource.Value := 'DifferentString';
    FInstantString.Assign(vSource);
    AssertEquals('String value is incorrect!', 'DifferentString',
      FInstantString.Value);
  finally
    vSource.Free;
  end;
end;

procedure TestTInstantString.TestAsString;
begin
  FInstantString.AsString := 'DifferentString';
  AssertEquals('Set AsString is incorrect!', 'DifferentString',
    FInstantString.Value);
  AssertEquals('Get AsString is incorrect!', 'DifferentString',
    FInstantString.AsString);
end;

procedure TestTInstantString.TestAsVariant;
begin                                           
  FInstantString.AsVariant := 'DifferentString';
  AssertEquals('Set AsVariant is incorrect!', 'DifferentString',
    FInstantString.Value);
  AssertEquals('Get AsVariant is incorrect!', 'DifferentString',
    FInstantString.AsVariant);
end;

procedure TestTInstantString.TestChange;
begin
  AssertTrue('IsChanged is false!', FInstantString.IsChanged);
  FInstantString.UnChanged;
  AssertFalse('IsChanged is true!', FInstantString.IsChanged);
  FInstantString.Value := FInstantString.Value + 's';
  AssertTrue('IsChanged is false!', FInstantString.IsChanged);
  FInstantString.UnChanged;
  AssertFalse('IsChanged is true!', FInstantString.IsChanged);
  FInstantString.Changed;
  AssertTrue('IsChanged is false!', FInstantString.IsChanged);
end;

procedure TestTInstantString.TestCheckHasMetadata;
begin
  try
    FInstantString.CheckHasMetadata;
  except
    Fail('CheckHasMetadata failed!');
  end;

  FInstantString.Metadata := nil;
  AssertException(EInstantError, FInstantString.CheckHasMetadata);
end;

procedure TestTInstantString.TestDisplayText;
begin
  AssertEquals('DisplayText is incorrect!', 'StringValue',
    FInstantString.DisplayText);

  FInstantString.Metadata.EditMask := '!CCCCCC';
  AssertEquals('DisplayText is incorrect!', 'gValue',
  FInstantString.DisplayText);

  FInstantString.Value := 'NewString';
  FInstantString.Metadata.EditMask := 'CCCCCC';
  AssertEquals('DisplayText is incorrect!', 'NewStr',
    FInstantString.DisplayText);
end;

procedure TestTInstantString.TestIsDefault;
begin
  AssertFalse('Value is default!', FInstantString.IsDefault);

  FInstantString.Value := '';
  AssertTrue('Value is not default!', FInstantString.IsDefault);
end;

procedure TestTInstantString.TestIsIndexed;
begin
  AssertFalse('Attribute is indexed!', FInstantString.IsIndexed);

  FInstantString.Metadata.IsIndexed := True;
  AssertTrue('Attribute is not indexed!', FInstantString.IsIndexed);
end;

procedure TestTInstantString.TestIsMandatory;
begin
  AssertFalse('Attribute is Mandatory!', FInstantString.IsMandatory);

  FInstantString.Metadata.IsIndexed := True;
  AssertTrue('Attribute is not Mandatory!', FInstantString.IsMandatory);
  FInstantString.Metadata.IsRequired := True;
  AssertTrue('Attribute is not Mandatory!', FInstantString.IsMandatory);
  FInstantString.Metadata.IsIndexed := False;
  AssertTrue('Attribute is not Mandatory!', FInstantString.IsMandatory);
end;

procedure TestTInstantString.TestIsRequired;
begin
  AssertFalse('Attribute is required!', FInstantString.IsRequired);

  FInstantString.Metadata.IsRequired := True;
  AssertTrue('Attribute is not required!', FInstantString.IsRequired);
end;

procedure TestTInstantString.TestMetadata;
begin
  AssertNotNull('Metadata is nil!', FInstantString.Metadata);
  AssertEquals('Metdata name is incorrect!', 'AttrMetadataName',
    FInstantString.Metadata.Name);

  FInstantString.Metadata := nil;
  AssertNull('Metadata is not nil!', FInstantString.Metadata);
  FInstantString.Reset;

  FInstantString.Metadata := FAttrMetadata;
  AssertNotNull('Metadata is nil!', FInstantString.Metadata);
  AssertEquals('Metdata name is incorrect!', 'AttrMetadataName',
    FInstantString.Metadata.Name);
end;

procedure TestTInstantString.TestName;
begin
  AssertEquals('Attribute name is incorrect!', 'AttrMetadataName',
    FInstantString.Name);
end;

procedure TestTInstantString.TestOwner;
begin
  AssertSame('Owner is incorrect!', FOwner, FInstantString.Owner);
end;

procedure TestTInstantString.TestReset;
begin
  AssertNotNull('Metadata is nil!', FInstantString.Metadata);
  // Metadata.DefaultValue is '';
  FInstantString.Reset;
  AssertEquals('Reset value is incorrect!', '', FInstantString.Value);

  FInstantString.Metadata.DefaultValue := '1000';
  FInstantString.Reset;
  AssertEquals('Reset value is incorrect!', '1000', FInstantString.Value);

  FInstantString.Metadata := nil;
  AssertNull('Metadata is not nil!', FInstantString.Metadata);
  FInstantString.Reset;
  AssertEquals('Reset value is incorrect!', '', FInstantString.Value);
end;

procedure TestTInstantString.TestValue;
begin
  AssertEquals('Value is incorrect!', 'StringValue', FInstantString.Value);
  FInstantString.Value := 'NewValue';
  AssertEquals('Value is incorrect!', 'NewValue', FInstantString.Value);
end;

initialization
  // Register any test cases with the test runner
{$IFNDEF CURR_TESTS}
  RegisterTests([TestTInstantString]);
{$ENDIF}

end.

Index: TestInstantInteger.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantInteger.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantInteger.pas	5 May 2005 07:15:01 -0000	1.1
--- TestInstantInteger.pas	6 May 2005 05:41:28 -0000	1.2
***************
*** 224,228 ****
  procedure TestTInstantInteger.TestIsRequired;
  begin
-   // TODO -cMM: TestTInstantInteger.TestIsRequired default body inserted
    AssertFalse('Attribute is required!', FInstantInteger.IsRequired);

--- 224,227 ----
***************
*** 260,267 ****
  procedure TestTInstantInteger.TestReset;
  begin
    // Metadata.DefaultValue is '';
    FInstantInteger.Reset;
    AssertEquals('Reset value is incorrect!', 0, FInstantInteger.Value);
-   AssertNotNull('Metadata is nil!', FInstantInteger.Metadata);

    FInstantInteger.Metadata.DefaultValue := '1000';
--- 259,266 ----
  procedure TestTInstantInteger.TestReset;
  begin
+   AssertNotNull('Metadata is nil!', FInstantInteger.Metadata);
    // Metadata.DefaultValue is '';
    FInstantInteger.Reset;
    AssertEquals('Reset value is incorrect!', 0, FInstantInteger.Value);

    FInstantInteger.Metadata.DefaultValue := '1000';

Index: TestIO.dpr
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestIO.dpr,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** TestIO.dpr	5 May 2005 07:15:03 -0000	1.6
--- TestIO.dpr	6 May 2005 05:41:28 -0000	1.7
***************
*** 30,34 ****
    TestMinimalModel in 'TestMinimalModel.pas',
    TestInstantAttributeMap in 'TestInstantAttributeMap.pas',
!   TestInstantInteger in 'TestInstantInteger.pas';

  {$R *.res}
--- 30,36 ----
    TestMinimalModel in 'TestMinimalModel.pas',
    TestInstantAttributeMap in 'TestInstantAttributeMap.pas',
!   TestInstantInteger in 'TestInstantInteger.pas',
!   TestInstantString in 'TestInstantString.pas',
!   TestInstantDateTime in 'TestInstantDateTime.pas';

  {$R *.res}

[Instantobjects-cvscommit] Source/Tests TestInstantDateTime.pas,NONE,1.1 TestInstantString.pas,NONE,

[Instantobjects-cvscommit] Source/Tests TestInstantDateTime.pas,NONE,1.1 TestInstantString.pas,NONE,1.1 TestIO.dpr,1.6,1.7 TestInstantInteger.pas,1.1,1.2