[Instantobjects-cvscommit] Source/Tests TestInstantCurrency.pas,NONE,1.1 TestInstantFloat.pas,NONE,1.1 TestInstantNumeric.pas,NONE,1.1 TestInstantAttribute.pas,NONE,1.1 TestInstantBoolean.pas,NONE,1.1 TestIO.dpr,1.7,1.8 TestInstantInteger.pas,1.2,1.3 TestInstantDateTime.pas,1.1,1.2 TestInstantString.pas,1.1,1.2

[Steven M. <sr...@us...>]

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

Modified Files:
	TestIO.dpr TestInstantInteger.pas TestInstantDateTime.pas 
	TestInstantString.pas 
Added Files:
	TestInstantCurrency.pas TestInstantFloat.pas 
	TestInstantNumeric.pas TestInstantAttribute.pas 
	TestInstantBoolean.pas 
Log Message:
Added Test for the following classes:
TInstantAttribute
TInstantNumeric
TInstantFloat
TInstantCurrency
TInstantBoolean
Refactored tests for the following classes:
TInstantInteger
TInstantDateTime
TInstantString

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

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantNumeric
  TestTInstantNumeric = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantNumeric: TInstantNumeric;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAsBoolean;
    procedure TestAsDateTime;
    procedure TestAsObject;
    procedure TestDisplayText;
    procedure TestIsDefault;
  end;

implementation

uses SysUtils, testregistry, InstantClasses;

procedure TestTInstantNumeric.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantInteger;
  FAttrMetadata.Name := 'AttrMetadataName';
  // TInstantNumeric is abstract so use TInstantInteger
  FInstantNumeric := TInstantInteger.Create(FOwner, FAttrMetadata);
end;

procedure TestTInstantNumeric.TearDown;
begin
  FreeAndNil(FInstantNumeric);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

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

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

procedure TestTInstantNumeric.TestAsDateTime;
begin
  FInstantNumeric.AsDateTime := 12.45;
  AssertEquals('Set AsDateTime is incorrect!', 12, FInstantNumeric.Value);
  AssertEquals('Get AsDateTime is incorrect!', 12.0,
    FInstantNumeric.AsDateTime);
end;

procedure TestTInstantNumeric.TestAsObject;
begin
  try
    FInstantNumeric.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
    FInstantNumeric.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 TestTInstantNumeric.TestDisplayText;
begin
  FInstantNumeric.Value := 1;
  AssertEquals('DisplayText is incorrect!', '1', FInstantNumeric.DisplayText);

  FInstantNumeric.Metadata.EditMask := '000';
  AssertEquals('DisplayText is incorrect!', '001', FInstantNumeric.DisplayText);

  FInstantNumeric.Value := 1000;
  FInstantNumeric.Metadata.EditMask := '#' + ThousandSeparator + '000';
  AssertEquals('DisplayText is incorrect!', '1' + ThousandSeparator + '000',
    FInstantNumeric.DisplayText);
end;

procedure TestTInstantNumeric.TestIsDefault;
begin
  AssertTrue('Value is not default!', FInstantNumeric.IsDefault);

  FInstantNumeric.Value := 100;
  AssertFalse('Value is default!', FInstantNumeric.IsDefault);
end;

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

end.
 
--- NEW FILE: TestInstantFloat.pas ---
unit TestInstantFloat;

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantFloat
  TestTInstantFloat = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantFloat: TInstantFloat;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAsCurrency;
    procedure TestAsFloat;
    procedure TestAsInteger;
    procedure TestAssign;
    procedure TestAsString;
    procedure TestAsVariant;
    procedure TestReset;
    procedure TestValue;
  end;

implementation

uses SysUtils, testregistry, InstantClasses;

procedure TestTInstantFloat.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantFloat;
  FAttrMetadata.Name := 'AttrMetadataName';
  FInstantFloat := TInstantFloat.Create(FOwner, FAttrMetadata);
  FInstantFloat.Value := 1.3;
end;

procedure TestTInstantFloat.TearDown;
begin
  FreeAndNil(FInstantFloat);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

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

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

procedure TestTInstantFloat.TestAsInteger;
begin
  FInstantFloat.AsInteger := 89;
  AssertEquals('Set AsInteger is incorrect!', 89.0, FInstantFloat.Value);
  AssertEquals('Get AsInteger is incorrect!', 89.0, FInstantFloat.AsInteger);
end;

procedure TestTInstantFloat.TestAssign;
var
  vSource: TInstantFloat;
begin
  AssertEquals('Value is incorrect!', 1.3, FInstantFloat.Value);
  vSource := TInstantFloat.Create;
  try
    VSource.Value := 4.3;
    FInstantFloat.Assign(vSource);
    AssertEquals('Value is incorrect!', 4.3, FInstantFloat.Value);
  finally
    vSource.Free;
  end;
end;

procedure TestTInstantFloat.TestAsString;
begin
  FInstantFloat.AsString := '1.3';
  AssertEquals('Set AsString is incorrect!', 1.3, FInstantFloat.Value);
  AssertEquals('Get AsString is incorrect!', '1.3', FInstantFloat.AsString);
end;

procedure TestTInstantFloat.TestAsVariant;
begin                                           
  FInstantFloat.AsVariant := 15.1;
  AssertEquals('Set AsVariant is incorrect!', 15.1, FInstantFloat.Value);
  AssertEquals('Get AsVariant is incorrect!', 15.1, FInstantFloat.AsVariant);
end;

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

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

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

procedure TestTInstantFloat.TestValue;
begin
  AssertEquals('Value is incorrect!', 1.3, FInstantFloat.Value);
  FInstantFloat.Value := 97.2;
  AssertEquals('Value is incorrect!', 97.2, FInstantFloat.Value);
end;

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

end.
 
--- NEW FILE: TestInstantAttribute.pas ---
unit TestInstantAttribute;

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantAttribute
  TestTInstantAttribute = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantAttribute: TInstantAttribute;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestChange;
    procedure TestCheckHasMetadata;
    procedure TestDisplayText;
    procedure TestIsDefault;
    procedure TestIsIndexed;
    procedure TestIsMandatory;
    procedure TestIsRequired;
    procedure TestMetadata;
  end;

implementation

uses SysUtils, testregistry, InstantClasses;

procedure TestTInstantAttribute.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantString;
  FAttrMetadata.Name := 'AttrMetadataName';
  // TInstantAttribute is abstract so use TInstantString
  FInstantAttribute := TInstantString.Create(FOwner, FAttrMetadata);
end;

procedure TestTInstantAttribute.TearDown;
begin
  FreeAndNil(FInstantAttribute);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

procedure TestTInstantAttribute.TestChange;
begin
  AssertFalse('IsChanged is true!', FInstantAttribute.IsChanged);
  FInstantAttribute.Value := 'NewString';
  AssertTrue('IsChanged is false!', FInstantAttribute.IsChanged);
  FInstantAttribute.UnChanged;
  AssertFalse('IsChanged is true!', FInstantAttribute.IsChanged);
  FInstantAttribute.Changed;
  AssertTrue('IsChanged is false!', FInstantAttribute.IsChanged);
end;

procedure TestTInstantAttribute.TestCheckHasMetadata;
begin
  try
    FInstantAttribute.CheckHasMetadata;
  except
    Fail('CheckHasMetadata failed!');
  end;

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

procedure TestTInstantAttribute.TestDisplayText;
begin
  FInstantAttribute.Value := 'StringValue';
  AssertEquals('DisplayText is incorrect!', 'StringValue',
    FInstantAttribute.DisplayText);

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

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

procedure TestTInstantAttribute.TestIsDefault;
begin
  AssertTrue('Value is not default!', FInstantAttribute.IsDefault);

  FInstantAttribute.Value := 'NewString';
  AssertFalse('Value is default!', FInstantAttribute.IsDefault);
end;

procedure TestTInstantAttribute.TestIsIndexed;
begin
  AssertFalse('Attribute is indexed!', FInstantAttribute.IsIndexed);

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

procedure TestTInstantAttribute.TestIsMandatory;
begin
  AssertFalse('Attribute is Mandatory!', FInstantAttribute.IsMandatory);

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

procedure TestTInstantAttribute.TestIsRequired;
begin
  AssertFalse('Attribute is required!', FInstantAttribute.IsRequired);

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

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

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

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

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

end.
 
Index: TestInstantInteger.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantInteger.pas,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TestInstantInteger.pas	6 May 2005 05:41:28 -0000	1.2
--- TestInstantInteger.pas	7 May 2005 04:59:48 -0000	1.3
***************
*** 18,40 ****
      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;
--- 18,27 ----
***************
*** 65,79 ****
  end;
  
- procedure TestTInstantInteger.TestAsBoolean;
- begin
-   FInstantInteger.AsBoolean := True;
-   AssertEquals('Set AsBoolean is incorrect!', 1, FInstantInteger.Value);
-   AssertTrue('Get AsBoolean is false!', FInstantInteger.AsBoolean);
- 
-   FInstantInteger.AsBoolean := False;
-   AssertEquals('Set AsBoolean is incorrect!', 0, FInstantInteger.Value);
-   AssertFalse('Get AsBoolean is true!', FInstantInteger.AsBoolean);
- end;
- 
  procedure TestTInstantInteger.TestAsCurrency;
  begin
--- 52,55 ----
***************
*** 84,95 ****
  end;
  
- procedure TestTInstantInteger.TestAsDateTime;
- begin
-   FInstantInteger.AsDateTime := 12.45;
-   AssertEquals('Set AsDateTime is incorrect!', 12, FInstantInteger.Value);
-   AssertEquals('Get AsDateTime is incorrect!', 12.0,
-     FInstantInteger.AsDateTime);
- end;
- 
  procedure TestTInstantInteger.TestAsFloat;
  begin
--- 60,63 ----
***************
*** 106,129 ****
  end;
  
- procedure TestTInstantInteger.TestAsObject;
- begin
-   try
-     FInstantInteger.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
-     FInstantInteger.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 TestTInstantInteger.TestAssign;
  var
--- 74,77 ----
***************
*** 156,260 ****
  end;
  
- procedure TestTInstantInteger.TestChange;
- begin
-   AssertTrue('IsChanged is false!', FInstantInteger.IsChanged);
-   FInstantInteger.UnChanged;
-   AssertFalse('IsChanged is true!', FInstantInteger.IsChanged);
-   FInstantInteger.Value := FInstantInteger.Value + 1;
-   AssertTrue('IsChanged is false!', FInstantInteger.IsChanged);
-   FInstantInteger.UnChanged;
-   AssertFalse('IsChanged is true!', FInstantInteger.IsChanged);
-   FInstantInteger.Changed;
-   AssertTrue('IsChanged is false!', FInstantInteger.IsChanged);
- end;
- 
- procedure TestTInstantInteger.TestCheckHasMetadata;
- begin
-   try
-     FInstantInteger.CheckHasMetadata;
-   except
-     Fail('CheckHasMetadata failed!');
-   end;
- 
-   FInstantInteger.Metadata := nil;
-   AssertException(EInstantError, FInstantInteger.CheckHasMetadata);
- end;
- 
- procedure TestTInstantInteger.TestDisplayText;
- begin
-   AssertEquals('DisplayText is incorrect!', '1', FInstantInteger.DisplayText);
- 
-   FInstantInteger.Metadata.EditMask := '000';
-   AssertEquals('DisplayText is incorrect!', '001', FInstantInteger.DisplayText);
- 
-   FInstantInteger.Value := 1000;
-   FInstantInteger.Metadata.EditMask := '#' + ThousandSeparator + '000';
-   AssertEquals('DisplayText is incorrect!', '1' + ThousandSeparator + '000',
-     FInstantInteger.DisplayText);
- end;
- 
- procedure TestTInstantInteger.TestIsDefault;
- begin
-   AssertFalse('Value is default!', FInstantInteger.IsDefault);
- 
-   FInstantInteger.Value := 0;
-   AssertTrue('Value is not default!', FInstantInteger.IsDefault);
- end;
- 
- procedure TestTInstantInteger.TestIsIndexed;
- begin
-   AssertFalse('Attribute is indexed!', FInstantInteger.IsIndexed);
- 
-   FInstantInteger.Metadata.IsIndexed := True;
-   AssertTrue('Attribute is not indexed!', FInstantInteger.IsIndexed);
- end;
- 
- procedure TestTInstantInteger.TestIsMandatory;
- begin
-   AssertFalse('Attribute is Mandatory!', FInstantInteger.IsMandatory);
- 
-   FInstantInteger.Metadata.IsIndexed := True;
-   AssertTrue('Attribute is not Mandatory!', FInstantInteger.IsMandatory);
-   FInstantInteger.Metadata.IsRequired := True;
-   AssertTrue('Attribute is not Mandatory!', FInstantInteger.IsMandatory);
-   FInstantInteger.Metadata.IsIndexed := False;
-   AssertTrue('Attribute is not Mandatory!', FInstantInteger.IsMandatory);
- end;
- 
- procedure TestTInstantInteger.TestIsRequired;
- begin
-   AssertFalse('Attribute is required!', FInstantInteger.IsRequired);
- 
-   FInstantInteger.Metadata.IsRequired := True;
-   AssertTrue('Attribute is not required!', FInstantInteger.IsRequired);
- end;
- 
- procedure TestTInstantInteger.TestMetadata;
- begin
-   AssertNotNull('Metadata is nil!', FInstantInteger.Metadata);
-   AssertEquals('Metdata name is incorrect!', 'AttrMetadataName',
-     FInstantInteger.Metadata.Name);
- 
-   FInstantInteger.Metadata := nil;
-   AssertNull('Metadata is not nil!', FInstantInteger.Metadata);
-   FInstantInteger.Reset;
- 
-   FInstantInteger.Metadata := FAttrMetadata;
-   AssertNotNull('Metadata is nil!', FInstantInteger.Metadata);
-   AssertEquals('Metdata name is incorrect!', 'AttrMetadataName',
-     FInstantInteger.Metadata.Name);
- end;
- 
- procedure TestTInstantInteger.TestName;
- begin
-   AssertEquals('Attribute name is incorrect!', 'AttrMetadataName',
-     FInstantInteger.Name);
- end;
- 
- procedure TestTInstantInteger.TestOwner;
- begin
-   AssertSame('Owner is incorrect!', FOwner, FInstantInteger.Owner);
- end;
- 
  procedure TestTInstantInteger.TestReset;
  begin
--- 104,107 ----

Index: TestInstantString.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantString.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantString.pas	6 May 2005 05:41:28 -0000	1.1
--- TestInstantString.pas	7 May 2005 04:59:49 -0000	1.2
***************
*** 27,38 ****
      procedure TestAsString;
      procedure TestAsVariant;
-     procedure TestChange;
-     procedure TestCheckHasMetadata;
-     procedure TestDisplayText;
-     procedure TestIsDefault;
-     procedure TestIsIndexed;
-     procedure TestIsMandatory;
-     procedure TestIsRequired;
-     procedure TestMetadata;
      procedure TestName;
      procedure TestOwner;
--- 27,30 ----
***************
*** 163,258 ****
  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
--- 155,158 ----

Index: TestInstantDateTime.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantDateTime.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantDateTime.pas	6 May 2005 05:41:28 -0000	1.1
--- TestInstantDateTime.pas	7 May 2005 04:59:48 -0000	1.2
***************
*** 27,40 ****
      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;
--- 27,32 ----
***************
*** 210,238 ****
  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
--- 202,205 ----
***************
*** 263,321 ****
  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
--- 230,233 ----

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

interface

uses fpcunit, InstantPersistence, InstantMock;

Type

  // Test methods for class TInstantBoolean
  TestTInstantBoolean = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantBoolean: TInstantBoolean;
    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 TestDisplayText;
    procedure TestIsDefault;
    procedure TestReset;
    procedure TestValue;
  end;

implementation

uses SysUtils, testregistry, InstantClasses, InstantConsts;

procedure TestTInstantBoolean.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantBoolean;
  FAttrMetadata.Name := 'AttrMetadataName';
  FInstantBoolean := TInstantBoolean.Create(FOwner, FAttrMetadata);
  FInstantBoolean.Value := False;
end;

procedure TestTInstantBoolean.TearDown;
begin
  FreeAndNil(FInstantBoolean);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

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

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

procedure TestTInstantBoolean.TestAsCurrency;
begin
  FInstantBoolean.AsCurrency := 89.45;
  AssertTrue('Set AsCurrency is incorrect!', FInstantBoolean.Value);
  AssertEquals('Get AsCurrency is incorrect!', 89.0, FInstantBoolean.AsCurrency);
end;

procedure TestTInstantBoolean.TestAsDateTime;
begin
  try
    FInstantBoolean.AsDateTime := 12.45;
    Fail('Exception was not thrown for Set AsDateTime!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
  else
    raise;
  end;
  try
    FInstantBoolean.AsDateTime;
    Fail('Exception was not thrown for Get AsDateTime!'); // should never get here
  except
    on E: EInstantAccessError do ; // do nothing as this is expected
  else
    raise;
  end;
end;

procedure TestTInstantBoolean.TestAsFloat;
begin
  FInstantBoolean.AsFloat := 89.45;
  AssertTrue('Set AsFloat is incorrect!', FInstantBoolean.Value);
  AssertEquals('Get AsFloat is incorrect!', 89.0, FInstantBoolean.AsFloat);
end;

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

procedure TestTInstantBoolean.TestAsObject;
begin
  try
    FInstantBoolean.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
    FInstantBoolean.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 TestTInstantBoolean.TestAssign;
var
  vSource: TInstantBoolean;
begin
  AssertEquals('String value is incorrect!', False,
    FInstantBoolean.Value);

  vSource := TInstantBoolean.Create;
  try
    VSource.Value := True;
    FInstantBoolean.Assign(vSource);
    AssertEquals('String value is incorrect!', True,
      FInstantBoolean.Value);
  finally
    vSource.Free;
  end;
end;

procedure TestTInstantBoolean.TestAsString;
begin
  FInstantBoolean.AsString := InstantTrueString;
  AssertTrue('Set AsString is incorrect!', FInstantBoolean.Value);
  AssertTrue('Get AsString is incorrect!', SameText(InstantTrueString,
    FInstantBoolean.AsString));
end;

procedure TestTInstantBoolean.TestAsVariant;
begin                                           
  FInstantBoolean.AsVariant := True;
  AssertTrue('Set AsVariant is incorrect!', FInstantBoolean.Value);
  AssertTrue('Get AsVariant is incorrect!', FInstantBoolean.AsVariant);
end;

procedure TestTInstantBoolean.TestDisplayText;
begin
  AssertTrue('DisplayText is incorrect!',
    SameText(InstantFalseString, FInstantBoolean.DisplayText));

  FInstantBoolean.Metadata.EditMask := '!CC';
  AssertEquals('DisplayText is incorrect!', 'se',
  FInstantBoolean.DisplayText);

  FInstantBoolean.Value := True;
  FInstantBoolean.Metadata.EditMask := 'CCC';
  AssertEquals('DisplayText is incorrect!', 'Tru',
    FInstantBoolean.DisplayText);
end;

procedure TestTInstantBoolean.TestIsDefault;
begin
  AssertTrue('Value is default!', FInstantBoolean.IsDefault);

  FInstantBoolean.Value := True;
  AssertFalse('Value is not default!', FInstantBoolean.IsDefault);
end;

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

  FInstantBoolean.Metadata.DefaultValue := InstantTrueString;
  FInstantBoolean.Reset;
  AssertEquals('Reset value is incorrect!', True, FInstantBoolean.Value);

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

procedure TestTInstantBoolean.TestValue;
begin
  AssertEquals('Value is incorrect!', False, FInstantBoolean.Value);
  FInstantBoolean.Value := True;
  AssertEquals('Value is incorrect!', True, FInstantBoolean.Value);
end;

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

end.
 
Index: TestIO.dpr
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestIO.dpr,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -d -r1.7 -r1.8
*** TestIO.dpr	6 May 2005 05:41:28 -0000	1.7
--- TestIO.dpr	7 May 2005 04:59:48 -0000	1.8
***************
*** 30,36 ****
    TestMinimalModel in 'TestMinimalModel.pas',
    TestInstantAttributeMap in 'TestInstantAttributeMap.pas',
    TestInstantInteger in 'TestInstantInteger.pas',
    TestInstantString in 'TestInstantString.pas',
!   TestInstantDateTime in 'TestInstantDateTime.pas';
  
  {$R *.res}
--- 30,41 ----
    TestMinimalModel in 'TestMinimalModel.pas',
    TestInstantAttributeMap in 'TestInstantAttributeMap.pas',
+   TestInstantAttribute in 'TestInstantAttribute.pas',
+   TestInstantNumeric in 'TestInstantNumeric.pas',
    TestInstantInteger in 'TestInstantInteger.pas',
    TestInstantString in 'TestInstantString.pas',
!   TestInstantDateTime in 'TestInstantDateTime.pas',
!   TestInstantBoolean in 'TestInstantBoolean.pas',
!   TestInstantFloat in 'TestInstantFloat.pas',
!   TestInstantCurrency in 'TestInstantCurrency.pas';
  
  {$R *.res}

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

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantCurrency
  TestTInstantCurrency = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantCurrency: TInstantCurrency;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAsCurrency;
    procedure TestAsFloat;
    procedure TestAsInteger;
    procedure TestAssign;
    procedure TestAsString;
    procedure TestAsVariant;
    procedure TestReset;
    procedure TestValue;
  end;

implementation

uses SysUtils, testregistry, InstantClasses;

procedure TestTInstantCurrency.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantCurrency;
  FAttrMetadata.Name := 'AttrMetadataName';
  FInstantCurrency := TInstantCurrency.Create(FOwner, FAttrMetadata);
  FInstantCurrency.Value := 1.3;
end;

procedure TestTInstantCurrency.TearDown;
begin
  FreeAndNil(FInstantCurrency);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

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

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

procedure TestTInstantCurrency.TestAsInteger;
begin
  FInstantCurrency.AsInteger := 89;
  AssertEquals('Set AsInteger is incorrect!', 89.0, FInstantCurrency.Value);
  AssertEquals('Get AsInteger is incorrect!', 89.0, FInstantCurrency.AsInteger);
end;

procedure TestTInstantCurrency.TestAssign;
var
  vSource: TInstantCurrency;
begin
  AssertEquals('Value is incorrect!', 1.3, FInstantCurrency.Value);
  vSource := TInstantCurrency.Create;
  try
    VSource.Value := 4.3;
    FInstantCurrency.Assign(vSource);
    AssertEquals('Value is incorrect!', 4.3, FInstantCurrency.Value);
  finally
    vSource.Free;
  end;
end;

procedure TestTInstantCurrency.TestAsString;
begin
  FInstantCurrency.AsString := '1.3';
  AssertEquals('Set AsString is incorrect!', 1.3, FInstantCurrency.Value);
  AssertEquals('Get AsString is incorrect!', '1.3', FInstantCurrency.AsString);
end;

procedure TestTInstantCurrency.TestAsVariant;
begin                                           
  FInstantCurrency.AsVariant := 15.1;
  AssertEquals('Set AsVariant is incorrect!', 15.1, FInstantCurrency.Value);
  AssertEquals('Get AsVariant is incorrect!', 15.1, FInstantCurrency.AsVariant);
end;

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

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

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

procedure TestTInstantCurrency.TestValue;
begin
  AssertEquals('Value is incorrect!', 1.3, FInstantCurrency.Value);
  FInstantCurrency.Value := 97.2;
  AssertEquals('Value is incorrect!', 97.2, FInstantCurrency.Value);
end;

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

end.