[Instantobjects-cvscommit] Source/Tests Picture.bmp,NONE,1.1 TestBlobText.txt,NONE,1.1 TestInstantBlob.pas,NONE,1.1 TestIO.dpr,1.9,1.10 TestInstantAttribute.pas,1.1,1.2 TestInstantBoolean.pas,1.2,1.3 TestInstantClassMetadata.pas,1.1,1.2 TestInstantCurrency.pas,1.2,1.3 TestInstantDateTime.pas,1.2,1.3 TestInstantFieldMetadata.pas,1.1,1.2 TestInstantFloat.pas,1.2,1.3 TestInstantIndexMetadata.pas,1.1,1.2 TestInstantInteger.pas,1.3,1.4 TestInstantMetadata.pas,1.1,1.2 TestInstantNumeric.pas,1.2,1.3 TestInstantScheme.pas,1.1,1.2 TestInstantString.pas,1.3,1.4 TestInstantTableMetadata.pas,1.1,1.2

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

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

Modified Files:
	TestIO.dpr TestInstantAttribute.pas TestInstantBoolean.pas 
	TestInstantClassMetadata.pas TestInstantCurrency.pas 
	TestInstantDateTime.pas TestInstantFieldMetadata.pas 
	TestInstantFloat.pas TestInstantIndexMetadata.pas 
	TestInstantInteger.pas TestInstantMetadata.pas 
	TestInstantNumeric.pas TestInstantScheme.pas 
	TestInstantString.pas TestInstantTableMetadata.pas 
Added Files:
	Picture.bmp TestBlobText.txt TestInstantBlob.pas 
Log Message:
Added tests for TInstantBlob class and tidied up code in previous test units.

Index: TestInstantFloat.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantFloat.pas,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TestInstantFloat.pas	8 May 2005 20:18:25 -0000	1.2
--- TestInstantFloat.pas	10 May 2005 05:31:08 -0000	1.3
***************
*** 53,61 ****
  
  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;
  
--- 53,63 ----
  
  procedure TestTInstantFloat.TestAsCurrency;
+ var
+   vCurr: Currency;
  begin
!   vCurr := 23.45;
!   FInstantFloat.AsCurrency := vCurr;
!   AssertEquals(23.45, FInstantFloat.Value);
!   AssertEquals(vCurr, FInstantFloat.AsCurrency);
  end;
  
***************
*** 63,68 ****
  begin
    FInstantFloat.AsFloat := 89.45;
!   AssertEquals('Set AsFloat is incorrect!', 89.45, FInstantFloat.Value);
!   AssertEquals('Get AsFloat is incorrect!', 89.45, FInstantFloat.AsFloat);
  end;
  
--- 65,70 ----
  begin
    FInstantFloat.AsFloat := 89.45;
!   AssertEquals(89.45, FInstantFloat.Value);
!   AssertEquals(89.45, FInstantFloat.AsFloat);
  end;
  
***************
*** 70,75 ****
  begin
    FInstantFloat.AsInteger := 89;
!   AssertEquals('Set AsInteger is incorrect!', 89.0, FInstantFloat.Value);
!   AssertEquals('Get AsInteger is incorrect!', 89.0, FInstantFloat.AsInteger);
  end;
  
--- 72,77 ----
  begin
    FInstantFloat.AsInteger := 89;
!   AssertEquals(89.0, FInstantFloat.Value);
!   AssertEquals(89.0, FInstantFloat.AsInteger);
  end;
  
***************
*** 78,87 ****
    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;
--- 80,89 ----
    vSource: TInstantFloat;
  begin
!   AssertEquals(1.3, FInstantFloat.Value);
    vSource := TInstantFloat.Create;
    try
      VSource.Value := 4.3;
      FInstantFloat.Assign(vSource);
!     AssertEquals(4.3, FInstantFloat.Value);
    finally
      vSource.Free;
***************
*** 92,97 ****
  begin
    FInstantFloat.AsString := '1' + DecimalSeparator + '3';
!   AssertEquals('Set AsString is incorrect!', 1.3, FInstantFloat.Value);
!   AssertEquals('Get AsString is incorrect!', '1' + DecimalSeparator + '3', FInstantFloat.AsString);
  end;
  
--- 94,99 ----
  begin
    FInstantFloat.AsString := '1' + DecimalSeparator + '3';
!   AssertEquals(1.3, FInstantFloat.Value);
!   AssertEquals('1' + DecimalSeparator + '3', FInstantFloat.AsString);
  end;
  
***************
*** 99,128 ****
  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' + DecimalSeparator + '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;
  
--- 101,130 ----
  begin                                           
    FInstantFloat.AsVariant := 15.1;
!   AssertEquals(15.1, FInstantFloat.Value);
!   AssertEquals(15.1, FInstantFloat.AsVariant);
  end;
  
  procedure TestTInstantFloat.TestReset;
  begin
!   AssertNotNull(FInstantFloat.Metadata);
    // Metadata.DefaultValue is '';
    FInstantFloat.Reset;
!   AssertEquals(1.3, FInstantFloat.Value);
  
    FInstantFloat.Metadata.DefaultValue := '15' + DecimalSeparator + '7';
    FInstantFloat.Reset;
!   AssertEquals(15.7, FInstantFloat.Value);
  
    FInstantFloat.Metadata := nil;
!   AssertNull(FInstantFloat.Metadata);
    FInstantFloat.Reset;
!   AssertEquals(0.0, FInstantFloat.Value);
  end;
  
  procedure TestTInstantFloat.TestValue;
  begin
!   AssertEquals(1.3, FInstantFloat.Value);
    FInstantFloat.Value := 97.2;
!   AssertEquals(97.2, FInstantFloat.Value);
  end;
  
***************
*** 134,136 ****
  
  end.
!  
--- 136,138 ----
  
  end.
!  
\ No newline at end of file

Index: TestInstantAttribute.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantAttribute.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantAttribute.pas	7 May 2005 04:59:48 -0000	1.1
--- TestInstantAttribute.pas	10 May 2005 05:31:08 -0000	1.2
***************
*** 3,7 ****
  interface
  
! uses fpcunit, InstantPersistence, InstantMock;
  
  type
--- 3,7 ----
  interface
  
! uses fpcunit, InstantPersistence;
  
  type
***************
*** 11,17 ****
    private
      FAttrMetadata: TInstantAttributeMetadata;
-     FConn: TInstantMockConnector;
      FInstantAttribute: TInstantAttribute;
-     FOwner: TInstantObject;
    public
      procedure SetUp; override;
--- 11,15 ----
***************
*** 34,45 ****
  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;
  
--- 32,40 ----
  procedure TestTInstantAttribute.SetUp;
  begin
    FAttrMetadata := TInstantAttributeMetadata.Create(nil);
    FAttrMetadata.AttributeClass := TInstantString;
    FAttrMetadata.Name := 'AttrMetadataName';
    // TInstantAttribute is abstract so use TInstantString
!   FInstantAttribute := TInstantString.Create(nil, FAttrMetadata);
  end;
  
***************
*** 48,64 ****
    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;
  
--- 43,57 ----
    FreeAndNil(FInstantAttribute);
    FreeAndNil(FAttrMetadata);
  end;
  
  procedure TestTInstantAttribute.TestChange;
  begin
!   AssertFalse(FInstantAttribute.IsChanged);
    FInstantAttribute.Value := 'NewString';
!   AssertTrue(FInstantAttribute.IsChanged);
    FInstantAttribute.UnChanged;
!   AssertFalse(FInstantAttribute.IsChanged);
    FInstantAttribute.Changed;
!   AssertTrue(FInstantAttribute.IsChanged);
  end;
  
***************
*** 78,144 ****
  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;
  
--- 71,132 ----
  begin
    FInstantAttribute.Value := 'StringValue';
!   AssertEquals('StringValue', FInstantAttribute.DisplayText);
  
    FInstantAttribute.Metadata.EditMask := '!CCCCCC';
!   AssertEquals('gValue', FInstantAttribute.DisplayText);
  
    FInstantAttribute.Value := 'NewString';
    FInstantAttribute.Metadata.EditMask := 'CCCCCC';
!   AssertEquals('NewStr', FInstantAttribute.DisplayText);
  end;
  
  procedure TestTInstantAttribute.TestIsDefault;
  begin
!   AssertTrue(FInstantAttribute.IsDefault);
  
    FInstantAttribute.Value := 'NewString';
!   AssertFalse(FInstantAttribute.IsDefault);
  end;
  
  procedure TestTInstantAttribute.TestIsIndexed;
  begin
!   AssertFalse(FInstantAttribute.IsIndexed);
  
    FInstantAttribute.Metadata.IsIndexed := True;
!   AssertTrue(FInstantAttribute.IsIndexed);
  end;
  
  procedure TestTInstantAttribute.TestIsMandatory;
  begin
!   AssertFalse(FInstantAttribute.IsMandatory);
  
    FInstantAttribute.Metadata.IsIndexed := True;
!   AssertTrue(FInstantAttribute.IsMandatory);
    FInstantAttribute.Metadata.IsRequired := True;
!   AssertTrue(FInstantAttribute.IsMandatory);
    FInstantAttribute.Metadata.IsIndexed := False;
!   AssertTrue(FInstantAttribute.IsMandatory);
  end;
  
  procedure TestTInstantAttribute.TestIsRequired;
  begin
!   AssertFalse(FInstantAttribute.IsRequired);
  
    FInstantAttribute.Metadata.IsRequired := True;
!   AssertTrue(FInstantAttribute.IsRequired);
  end;
  
  procedure TestTInstantAttribute.TestMetadata;
  begin
!   AssertNotNull(FInstantAttribute.Metadata);
!   AssertEquals('AttrMetadataName', FInstantAttribute.Metadata.Name);
  
    FInstantAttribute.Metadata := nil;
!   AssertNull(FInstantAttribute.Metadata);
    FInstantAttribute.Reset;
  
    FInstantAttribute.Metadata := FAttrMetadata;
!   AssertNotNull(FInstantAttribute.Metadata);
!   AssertEquals('AttrMetadataName', FInstantAttribute.Metadata.Name);
  end;
  

Index: TestInstantIndexMetadata.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantIndexMetadata.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantIndexMetadata.pas	3 May 2005 04:52:37 -0000	1.1
--- TestInstantIndexMetadata.pas	10 May 2005 05:31:08 -0000	1.2
***************
*** 60,85 ****
  procedure TestTInstantIndexMetadata.TestCollection;
  begin
!   AssertNotNull('Collection is nil!', FInstantIndexMetadata.Collection);
!   AssertSame('Collection is incorrect!', FCollection,
!     FInstantIndexMetadata.Collection);
  end;
  
  procedure TestTInstantIndexMetadata.TestFields;
  begin
!   AssertEquals('Fields value is incorrect!', 'IndexFields',
!     FInstantIndexMetadata.Fields);
  end;
  
  procedure TestTInstantIndexMetadata.TestOptions;
  begin
!   AssertTrue('Options value is incorrect!',
!     [ixPrimary, ixUnique] = FInstantIndexMetadata.Options);
  end;
  
  procedure TestTInstantIndexMetadata.TestTableMetadata;
  begin
!   AssertNotNull('TableMetadata is nil!', FInstantIndexMetadata.TableMetadata);
!   AssertSame('TableMetadata is incorrect!', FOwner,
!     FInstantIndexMetadata.TableMetadata);
  end;
  
--- 60,81 ----
  procedure TestTInstantIndexMetadata.TestCollection;
  begin
!   AssertNotNull(FInstantIndexMetadata.Collection);
!   AssertSame(FCollection, FInstantIndexMetadata.Collection);
  end;
  
  procedure TestTInstantIndexMetadata.TestFields;
  begin
!   AssertEquals('IndexFields', FInstantIndexMetadata.Fields);
  end;
  
  procedure TestTInstantIndexMetadata.TestOptions;
  begin
!   AssertTrue([ixPrimary, ixUnique] = FInstantIndexMetadata.Options);
  end;
  
  procedure TestTInstantIndexMetadata.TestTableMetadata;
  begin
!   AssertNotNull(FInstantIndexMetadata.TableMetadata);
!   AssertSame(FOwner, FInstantIndexMetadata.TableMetadata);
  end;
  
***************
*** 102,110 ****
  begin
    vReturnValue := FInstantIndexMetadatas.Add;
!   AssertNotNull('vReturnValue is nil!', vReturnValue);
!   AssertEquals('Count is incorrect!', 1, FInstantIndexMetadatas.Count);
!   AssertNotNull('Items[0] is nil!', FInstantIndexMetadatas.Items[0]);
    FInstantIndexMetadatas.Remove(vReturnValue);
!   AssertEquals('Count is incorrect!', 0, FInstantIndexMetadatas.Count);
  end;
  
--- 98,106 ----
  begin
    vReturnValue := FInstantIndexMetadatas.Add;
!   AssertNotNull(vReturnValue);
!   AssertEquals(1, FInstantIndexMetadatas.Count);
!   AssertNotNull('Items[0]', FInstantIndexMetadatas.Items[0]);
    FInstantIndexMetadatas.Remove(vReturnValue);
!   AssertEquals(0, FInstantIndexMetadatas.Count);
  end;
  
***************
*** 122,127 ****
    vReturnValue := TInstantIndexMetadata(FInstantIndexMetadatas.Find(vName));
    AssertNotNull('IndexMetadata not found!', vReturnValue);
!   AssertEquals('Fields value is incorrect!', vFields, vReturnValue.Fields);
!   AssertTrue('Options value is incorrect!', vOptions = vReturnValue.Options);
  end;
  
--- 118,123 ----
    vReturnValue := TInstantIndexMetadata(FInstantIndexMetadatas.Find(vName));
    AssertNotNull('IndexMetadata not found!', vReturnValue);
!   AssertEquals(vFields, vReturnValue.Fields);
!   AssertTrue('Options value', vOptions = vReturnValue.Options);
  end;
  
***************
*** 131,136 ****
  begin
    vReturnValue := FInstantIndexMetadatas.Owner;
!   AssertNotNull('Owner is nil!', vReturnValue);
!   AssertSame('Owner value is incorrect!', FOwner, vReturnValue);
  end;
  
--- 127,132 ----
  begin
    vReturnValue := FInstantIndexMetadatas.Owner;
!   AssertNotNull(vReturnValue);
!   AssertSame(FOwner, vReturnValue);
  end;
  

Index: TestInstantClassMetadata.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantClassMetadata.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantClassMetadata.pas	3 May 2005 04:52:37 -0000	1.1
--- TestInstantClassMetadata.pas	10 May 2005 05:31:08 -0000	1.2
***************
*** 77,87 ****
      vSource.Persistence := peStored;
      vDest.Assign(vSource);
!     AssertEquals('DefaultContainerName is incorrect!', 'DefaultContainerName',
!       vDest.DefaultContainerName);
!     AssertEquals('StorageName is incorrect!', 'StorageName',
!       vDest.StorageName);
      vStr := GetEnumName(TypeInfo(TInstantPersistence),
        Ord(vDest.Persistence));
!     AssertEquals('PersistenceType incorrect', 'peStored', vStr);
    finally
      vSource.Free;
--- 77,85 ----
      vSource.Persistence := peStored;
      vDest.Assign(vSource);
!     AssertEquals('DefaultContainerName', vDest.DefaultContainerName);
!     AssertEquals('StorageName', vDest.StorageName);
      vStr := GetEnumName(TypeInfo(TInstantPersistence),
        Ord(vDest.Persistence));
!     AssertEquals('peStored', vStr);
    finally
      vSource.Free;
***************
*** 92,97 ****
  procedure TestTInstantClassMetadata.TestAttributeMetadatas;
  begin
!   AssertNotNull('AttributeMetadatas is nil!',
!     FInstantClassMetadata.AttributeMetadatas);
  end;
  
--- 90,94 ----
  procedure TestTInstantClassMetadata.TestAttributeMetadatas;
  begin
!   AssertNotNull(FInstantClassMetadata.AttributeMetadatas);
  end;
  
***************
*** 99,109 ****
  begin
    // Collection property contains all of the class metadatas in the model
!   AssertNotNull('Collection is nil!', FInstantClassMetadata.Collection);
!   AssertEquals('The number of model classes is incorrect!', 9,
!     FInstantClassMetadata.Collection.Count);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TPhone');
!   AssertEquals('The number of model classes is incorrect!', 9,
!     FInstantClassMetadata.Collection.Count);
  end;
  
--- 96,104 ----
  begin
    // Collection property contains all of the class metadatas in the model
!   AssertNotNull(FInstantClassMetadata.Collection);
!   AssertEquals(9, FInstantClassMetadata.Collection.Count);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TPhone');
!   AssertEquals(9, FInstantClassMetadata.Collection.Count);
  end;
  
***************
*** 115,142 ****
  procedure TestTInstantClassMetadata.TestIsEmpty;
  begin
!   AssertFalse('FInstantClassMetadata is empty!', FInstantClassMetadata.IsEmpty);
  end;
  
  procedure TestTInstantClassMetadata.TestIsStored;
  begin
!   AssertTrue('Incorrect storage flag!', FInstantClassMetadata.IsStored);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TContactFilter');
!   AssertFalse('Incorrect storage flag!', FInstantClassMetadata.IsStored);
  end;
  
  procedure TestTInstantClassMetadata.TestMemberMap;
  begin
!   AssertNotNull('MemberMap is nil!', FInstantClassMetadata.MemberMap);
  end;
  
  procedure TestTInstantClassMetadata.TestParentName;
  begin
!   AssertEquals('ParentName incorrect!', '',
!     FInstantClassMetadata.ParentName);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TPerson');
!   AssertEquals('ParentName incorrect!', 'TContact',
!     FInstantClassMetadata.ParentName);
  end;
  
--- 110,135 ----
  procedure TestTInstantClassMetadata.TestIsEmpty;
  begin
!   AssertFalse(FInstantClassMetadata.IsEmpty);
  end;
  
  procedure TestTInstantClassMetadata.TestIsStored;
  begin
!   AssertTrue(FInstantClassMetadata.IsStored);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TContactFilter');
!   AssertFalse(FInstantClassMetadata.IsStored);
  end;
  
  procedure TestTInstantClassMetadata.TestMemberMap;
  begin
!   AssertNotNull(FInstantClassMetadata.MemberMap);
  end;
  
  procedure TestTInstantClassMetadata.TestParentName;
  begin
!   AssertEquals('', FInstantClassMetadata.ParentName);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TPerson');
!   AssertEquals('TContact', FInstantClassMetadata.ParentName);
  end;
  
***************
*** 147,164 ****
    vStr := GetEnumName(TypeInfo(TInstantPersistence),
      Ord(FInstantClassMetadata.Persistence));
!   AssertEquals('PersistenceType incorrect', 'peStored', vStr);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TContactFilter');
    vStr := GetEnumName(TypeInfo(TInstantPersistence),
      Ord(FInstantClassMetadata.Persistence));
!   AssertEquals('PersistenceType incorrect', 'peEmbedded', vStr);
  end;
  
  procedure TestTInstantClassMetadata.TestStorageMaps;
  begin
!   AssertNotNull('StorageMaps is nil!', FInstantClassMetadata.StorageMaps);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TContactFilter');
!   AssertNull('StorageMaps should be nil!', FInstantClassMetadata.StorageMaps);
  end;
  
--- 140,157 ----
    vStr := GetEnumName(TypeInfo(TInstantPersistence),
      Ord(FInstantClassMetadata.Persistence));
!   AssertEquals('peStored', vStr);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TContactFilter');
    vStr := GetEnumName(TypeInfo(TInstantPersistence),
      Ord(FInstantClassMetadata.Persistence));
!   AssertEquals('peEmbedded', vStr);
  end;
  
  procedure TestTInstantClassMetadata.TestStorageMaps;
  begin
!   AssertNotNull(FInstantClassMetadata.StorageMaps);
  
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TContactFilter');
!   AssertNull(FInstantClassMetadata.StorageMaps);
  end;
  
***************
*** 166,176 ****
  begin
    // Test with default class StorageName returns ''.
!   AssertEquals('StorageName incorrect!', '',
!     FInstantClassMetadata.StorageName);
  
    // Test for User entered non-default class StorageName.
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TCategory');
!   AssertEquals('StorageName incorrect!', 'Categories',
!     FInstantClassMetadata.StorageName);
  end;
  
--- 159,167 ----
  begin
    // Test with default class StorageName returns ''.
!   AssertEquals('', FInstantClassMetadata.StorageName);
  
    // Test for User entered non-default class StorageName.
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TCategory');
!   AssertEquals('Categories', FInstantClassMetadata.StorageName);
  end;
  
***************
*** 178,188 ****
  begin
    // Test with default class StorageName (TableName).
!   AssertEquals('TableName incorrect!', 'Contact',
!     FInstantClassMetadata.TableName);
  
    // Test for User entered non-default class StorageName (TableName).
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TCategory');
!   AssertEquals('TableName incorrect!', 'Categories',
!     FInstantClassMetadata.TableName);
  end;
  
--- 169,177 ----
  begin
    // Test with default class StorageName (TableName).
!   AssertEquals('Contact', FInstantClassMetadata.TableName);
  
    // Test for User entered non-default class StorageName (TableName).
    FInstantClassMetadata := InstantModel.ClassMetadatas.Find('TCategory');
!   AssertEquals('Categories', FInstantClassMetadata.TableName);
  end;
  
***************
*** 211,218 ****
  begin
    vReturnValue := FInstantClassMetadatas.Add;
!   AssertNotNull('vReturnValue is nil!', vReturnValue);
!   AssertEquals('Count is incorrect!', 4, FInstantClassMetadatas.Count);
    FInstantClassMetadatas.Remove(vReturnValue);
!   AssertEquals('Count is incorrect!', 3, FInstantClassMetadatas.Count);
  end;
  
--- 200,207 ----
  begin
    vReturnValue := FInstantClassMetadatas.Add;
!   AssertNotNull(vReturnValue);
!   AssertEquals(4, FInstantClassMetadatas.Count);
    FInstantClassMetadatas.Remove(vReturnValue);
!   AssertEquals(3, FInstantClassMetadatas.Count);
  end;
  
***************
*** 224,234 ****
    vName := 'TAddress';
    vReturnValue := FInstantClassMetadatas.Find(vName);
!   AssertEquals('TestFind failed!', vName, vReturnValue.Name);
  end;
  
  procedure TestTInstantClassMetadatas.TestItems;
  begin
!   AssertEquals('The second item''s name is incorrect!', 'TAddress',
!     FInstantClassMetadatas.Items[1].Name);
  end;
  
--- 213,222 ----
    vName := 'TAddress';
    vReturnValue := FInstantClassMetadatas.Find(vName);
!   AssertEquals(vName, vReturnValue.Name);
  end;
  
  procedure TestTInstantClassMetadatas.TestItems;
  begin
!   AssertEquals('TAddress', FInstantClassMetadatas.Items[1].Name);
  end;
  

Index: TestInstantFieldMetadata.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantFieldMetadata.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantFieldMetadata.pas	3 May 2005 04:52:37 -0000	1.1
--- TestInstantFieldMetadata.pas	10 May 2005 05:31:08 -0000	1.2
***************
*** 64,70 ****
  procedure TestTInstantFieldMetadata.TestCollection;
  begin
!   AssertNotNull('Collection is nil!', FInstantFieldMetadata.Collection);
!   AssertSame('Collection is incorrect!', FCollection,
!     FInstantFieldMetadata.Collection);
  end;
  
--- 64,69 ----
  procedure TestTInstantFieldMetadata.TestCollection;
  begin
!   AssertNotNull(FInstantFieldMetadata.Collection);
!   AssertSame(FCollection, FInstantFieldMetadata.Collection);
  end;
  
***************
*** 75,90 ****
    vStr := GetEnumName(TypeInfo(TInstantDataType),
      Ord(FInstantFieldMetadata.DataType));
!   AssertEquals('DataType incorrect!', 'dtInteger', vStr);
  end;
  
  procedure TestTInstantFieldMetadata.TestExternalTableName;
  begin
!   AssertEquals('ExternalTableName incorrect!', 'ExternalTableName',
!     FInstantFieldMetadata.ExternalTableName);
  end;
  
  procedure TestTInstantFieldMetadata.TestOptions;
  begin
!   AssertTrue('Options incorrect!', foRequired in FInstantFieldMetadata.Options);
  end;
  
--- 74,88 ----
    vStr := GetEnumName(TypeInfo(TInstantDataType),
      Ord(FInstantFieldMetadata.DataType));
!   AssertEquals('dtInteger', vStr);
  end;
  
  procedure TestTInstantFieldMetadata.TestExternalTableName;
  begin
!   AssertEquals('ExternalTableName', FInstantFieldMetadata.ExternalTableName);
  end;
  
  procedure TestTInstantFieldMetadata.TestOptions;
  begin
!   AssertTrue(foRequired in FInstantFieldMetadata.Options);
  end;
  
***************
*** 95,104 ****
    vStr := GetEnumName(TypeInfo(TInstantAttributeType),
      Ord(FInstantFieldMetadata.OriginalAttributeType));
!   AssertEquals('OriginalAttributeType incorrect!', 'atInteger', vStr);
  end;
  
  procedure TestTInstantFieldMetadata.TestSize;
  begin
!   AssertEquals('Size incorrect!', 10, FInstantFieldMetadata.Size);
  end;
  
--- 93,102 ----
    vStr := GetEnumName(TypeInfo(TInstantAttributeType),
      Ord(FInstantFieldMetadata.OriginalAttributeType));
!   AssertEquals('atInteger', vStr);
  end;
  
  procedure TestTInstantFieldMetadata.TestSize;
  begin
!   AssertEquals(10, FInstantFieldMetadata.Size);
  end;
  
***************
*** 121,129 ****
  begin
    vReturnValue := FInstantFieldMetadatas.Add;
!   AssertNotNull('vReturnValue is nil!', vReturnValue);
!   AssertEquals('Count is incorrect!', 1, FInstantFieldMetadatas.Count);
!   AssertNotNull('Items[0] is nil!', FInstantFieldMetadatas.Items[0]);
    FInstantFieldMetadatas.Remove(vReturnValue);
!   AssertEquals('Count is incorrect!', 0, FInstantFieldMetadatas.Count);
  end;
  
--- 119,127 ----
  begin
    vReturnValue := FInstantFieldMetadatas.Add;
!   AssertNotNull(vReturnValue);
!   AssertEquals(1, FInstantFieldMetadatas.Count);
!   AssertNotNull('Items[0]', FInstantFieldMetadatas.Items[0]);
    FInstantFieldMetadatas.Remove(vReturnValue);
!   AssertEquals(0, FInstantFieldMetadatas.Count);
  end;
  
***************
*** 148,172 ****
      vOriginalAttributeType, vOptions, vExternalTableName);
  
!   AssertEquals('Count is incorrect!', 1, FInstantFieldMetadatas.Count);
    vInstantFieldMetadata := FInstantFieldMetadatas.Items[0];
    AssertNotNull(vInstantFieldMetadata);
!   AssertEquals('Name is incorrect!', vName, vInstantFieldMetadata.Name);
!   AssertEquals('Size is incorrect!', 10, vInstantFieldMetadata.Size);
    vStr := GetEnumName(TypeInfo(TInstantAttributeType),
      Ord(vInstantFieldMetadata.OriginalAttributeType));
!   AssertEquals('OriginalAttributeType incorrect!', 'atInteger', vStr);
!   AssertTrue('Count is incorrect!',
!     foRequired in vInstantFieldMetadata.Options);
    vStr := GetEnumName(TypeInfo(TInstantDataType),
      Ord(vInstantFieldMetadata.DataType));
!   AssertEquals('DataType incorrect!', 'dtInteger', vStr);
!   AssertEquals('ExternalTableName is incorrect!', 'ExternalTableName',
!     vInstantFieldMetadata.ExternalTableName);
  end;
  
  procedure TestTInstantFieldMetadatas.TestOwner;
  begin
!   AssertNotNull('Owner is nil!', FInstantFieldMetadatas.Owner);
!   AssertSame('Owner value is incorrect!', FOwner, FInstantFieldMetadatas.Owner);
  end;
  
--- 146,168 ----
      vOriginalAttributeType, vOptions, vExternalTableName);
  
!   AssertEquals(1, FInstantFieldMetadatas.Count);
    vInstantFieldMetadata := FInstantFieldMetadatas.Items[0];
    AssertNotNull(vInstantFieldMetadata);
!   AssertEquals(vName, vInstantFieldMetadata.Name);
!   AssertEquals(10, vInstantFieldMetadata.Size);
    vStr := GetEnumName(TypeInfo(TInstantAttributeType),
      Ord(vInstantFieldMetadata.OriginalAttributeType));
!   AssertEquals('atInteger', vStr);
!   AssertTrue(foRequired in vInstantFieldMetadata.Options);
    vStr := GetEnumName(TypeInfo(TInstantDataType),
      Ord(vInstantFieldMetadata.DataType));
!   AssertEquals('dtInteger', vStr);
!   AssertEquals('ExternalTableName', vInstantFieldMetadata.ExternalTableName);
  end;
  
  procedure TestTInstantFieldMetadatas.TestOwner;
  begin
!   AssertNotNull(FInstantFieldMetadatas.Owner);
!   AssertSame(FOwner, FInstantFieldMetadatas.Owner);
  end;
  

Index: TestInstantTableMetadata.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantTableMetadata.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantTableMetadata.pas	3 May 2005 04:52:37 -0000	1.1
--- TestInstantTableMetadata.pas	10 May 2005 05:31:08 -0000	1.2
***************
*** 54,70 ****
  procedure TestTInstantTableMetadata.TestFieldMetadatas;
  begin
!   AssertNotNull('FieldMetadatas is nil!', FInstantTableMetadata.FieldMetadatas);
  end;
  
  procedure TestTInstantTableMetadata.TestIndexMetadatas;
  begin
!   AssertNotNull('IndexMetadatas is nil!', FInstantTableMetadata.IndexMetadatas);
  end;
  
  procedure TestTInstantTableMetadata.TestScheme;
  begin
!   AssertNotNull('Scheme is nil!', FInstantTableMetadata.Scheme);
!   AssertSame('Scheme value is incorrect!', FOwner,
!     FInstantTableMetadata.Scheme);
  end;
  
--- 54,69 ----
  procedure TestTInstantTableMetadata.TestFieldMetadatas;
  begin
!   AssertNotNull(FInstantTableMetadata.FieldMetadatas);
  end;
  
  procedure TestTInstantTableMetadata.TestIndexMetadatas;
  begin
!   AssertNotNull(FInstantTableMetadata.IndexMetadatas);
  end;
  
  procedure TestTInstantTableMetadata.TestScheme;
  begin
!   AssertNotNull(FInstantTableMetadata.Scheme);
!   AssertSame(FOwner, FInstantTableMetadata.Scheme);
  end;
  
***************
*** 85,93 ****
  begin
    vReturnValue := FInstantTableMetadatas.Add;
!   AssertNotNull('vReturnValue is nil!', vReturnValue);
!   AssertEquals('Count is incorrect!', 1, FInstantTableMetadatas.Count);
!   AssertNotNull('Items[0] is nil!', FInstantTableMetadatas.Items[0]);
    FInstantTableMetadatas.Remove(vReturnValue);
!   AssertEquals('Count is incorrect!', 0, FInstantTableMetadatas.Count);
  end;
  
--- 84,92 ----
  begin
    vReturnValue := FInstantTableMetadatas.Add;
!   AssertNotNull(vReturnValue);
!   AssertEquals(1, FInstantTableMetadatas.Count);
!   AssertNotNull('Items[0]', FInstantTableMetadatas.Items[0]);
    FInstantTableMetadatas.Remove(vReturnValue);
!   AssertEquals(0, FInstantTableMetadatas.Count);
  end;
  

Index: TestInstantDateTime.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantDateTime.pas,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TestInstantDateTime.pas	7 May 2005 04:59:48 -0000	1.2
--- TestInstantDateTime.pas	10 May 2005 05:31:08 -0000	1.3
***************
*** 100,107 ****
  begin
    FInstantDateTime.AsDateTime := 12.45;
!   AssertEquals('Set AsDateTime is incorrect!', 12.45,
!     FInstantDateTime.Value);
!   AssertEquals('Get AsDateTime is incorrect!', 12.45,
!     FInstantDateTime.AsDateTime);
  end;
  
--- 100,105 ----
  begin
    FInstantDateTime.AsDateTime := 12.45;
!   AssertEquals(12.45, FInstantDateTime.Value);
!   AssertEquals(12.45, FInstantDateTime.AsDateTime);
  end;
  
***************
*** 170,175 ****
    vSource: TInstantDateTime;
  begin
!   AssertEquals('String value is incorrect!', 100.5,
!     FInstantDateTime.Value);
  
    vSource := TInstantDateTime.Create;
--- 168,172 ----
    vSource: TInstantDateTime;
  begin
!   AssertEquals(100.5, FInstantDateTime.Value);
  
    vSource := TInstantDateTime.Create;
***************
*** 177,182 ****
      VSource.Value := 115.3;
      FInstantDateTime.Assign(vSource);
!     AssertEquals('String value is incorrect!', 115.3,
!       FInstantDateTime.Value);
    finally
      vSource.Free;
--- 174,178 ----
      VSource.Value := 115.3;
      FInstantDateTime.Assign(vSource);
!     AssertEquals(115.3, FInstantDateTime.Value);
    finally
      vSource.Free;
***************
*** 187,194 ****
  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;
  
--- 183,188 ----
  begin
    FInstantDateTime.AsString := DateTimeToStr(14.5);
!   AssertEquals(14.5, FInstantDateTime.Value);
!   AssertEquals(DateTimeToStr(14.5), FInstantDateTime.AsString);
  end;
  
***************
*** 196,203 ****
  begin                                           
    FInstantDateTime.AsVariant := 150.6;
!   AssertEquals('Set AsVariant is incorrect!', 150.6,
!     FInstantDateTime.Value);
!   AssertEquals('Get AsVariant is incorrect!', 150.6,
!     FInstantDateTime.AsVariant);
  end;
  
--- 190,195 ----
  begin                                           
    FInstantDateTime.AsVariant := 150.6;
!   AssertEquals(150.6, FInstantDateTime.Value);
!   AssertEquals(150.6, FInstantDateTime.AsVariant);
  end;
  
***************
*** 206,216 ****
    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;
--- 198,206 ----
    vDateTimeStr: string;
  begin
!   AssertEquals(FInstantDateTime.AsString, FInstantDateTime.DisplayText);
  
    DateTimeToString(vDateTimeStr, 'yyyymmddhhnnsszzz', FInstantDateTime.Value);
    FInstantDateTime.Metadata.EditMask := 'yyyymmddhhnnsszzz';
!   AssertEquals(vDateTimeStr, FInstantDateTime.DisplayText);
  
    FInstantDateTime.Value := 113.8;
***************
*** 218,231 ****
      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;
  
--- 208,220 ----
      FInstantDateTime.Value);
    FInstantDateTime.Metadata.EditMask := 'dd mmm yyyy hh:nn:ss ampm';
!   AssertEquals(vDateTimeStr, FInstantDateTime.DisplayText);
  end;
  
  procedure TestTInstantDateTime.TestIsDefault;
  begin
!   AssertFalse(FInstantDateTime.IsDefault);
  
    FInstantDateTime.Value := 0;
!   AssertTrue(FInstantDateTime.IsDefault);
  end;
  
***************
*** 234,258 ****
    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;
  
--- 223,247 ----
    vDateTimeStr: string;
  begin
!   AssertNotNull(FInstantDateTime.Metadata);
    // Metadata.DefaultValue is '';
    FInstantDateTime.Reset;
!   AssertEquals(0, FInstantDateTime.Value);
  
    DateTimeToString(vDateTimeStr, 'yyyymmddhhnnsszzz', 100.5);
    FInstantDateTime.Metadata.DefaultValue := vDateTimeStr;
    FInstantDateTime.Reset;
!   AssertEquals(100.5, FInstantDateTime.Value);
  
    FInstantDateTime.Metadata := nil;
!   AssertNull(FInstantDateTime.Metadata);
    FInstantDateTime.Reset;
!   AssertEquals(0, FInstantDateTime.Value);
  end;
  
  procedure TestTInstantDateTime.TestValue;
  begin
!   AssertEquals(100.5, FInstantDateTime.Value);
    FInstantDateTime.Value := 151.3;
!   AssertEquals(151.3, FInstantDateTime.Value);
  end;
  

Index: TestIO.dpr
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestIO.dpr,v
retrieving revision 1.9
retrieving revision 1.10
diff -C2 -d -r1.9 -r1.10
*** TestIO.dpr	8 May 2005 22:26:21 -0000	1.9
--- TestIO.dpr	10 May 2005 05:31:08 -0000	1.10
***************
*** 37,41 ****
    TestInstantBoolean in 'TestInstantBoolean.pas',
    TestInstantFloat in 'TestInstantFloat.pas',
!   TestInstantCurrency in 'TestInstantCurrency.pas';
  
  {$R *.res}
--- 37,42 ----
    TestInstantBoolean in 'TestInstantBoolean.pas',
    TestInstantFloat in 'TestInstantFloat.pas',
!   TestInstantCurrency in 'TestInstantCurrency.pas',
!   TestInstantBlob in 'TestInstantBlob.pas';
  
  {$R *.res}

Index: TestInstantCurrency.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantCurrency.pas,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TestInstantCurrency.pas	7 May 2005 08:17:32 -0000	1.2
--- TestInstantCurrency.pas	10 May 2005 05:31:08 -0000	1.3
***************
*** 3,12 ****
  interface
  
! uses fpcunit, InstantPersistence, InstantMock;
  
  type
  
    // Test methods for class TInstantCurrency
!   TTestInstantCurrency = class(TTestCase)
    private
      FAttrMetadata: TInstantAttributeMetadata;
--- 3,12 ----
  interface
  
! uses fpcunit, InstantPersistence;
  
  type
  
    // Test methods for class TInstantCurrency
!   TestTInstantCurrency = class(TTestCase)
    private
      FAttrMetadata: TInstantAttributeMetadata;
***************
*** 16,20 ****
--- 16,25 ----
      procedure TearDown; override;
    published
+     procedure TestAsCurrency;
+     procedure TestAsFloat;
+     procedure TestAsInteger;
      procedure TestAssign;
+     procedure TestAsString;
+     procedure TestAsVariant;
      procedure TestReset;
      procedure TestValue;
***************
*** 25,29 ****
  uses SysUtils, testregistry, InstantClasses;
  
! procedure TTestInstantCurrency.SetUp;
  begin
    FAttrMetadata := TInstantAttributeMetadata.Create(nil);
--- 30,36 ----
  uses SysUtils, testregistry, InstantClasses;
  
! procedure TestTInstantCurrency.SetUp;
! var
!   vCurr: Currency;
  begin
    FAttrMetadata := TInstantAttributeMetadata.Create(nil);
***************
*** 31,38 ****
    FAttrMetadata.Name := 'AttrMetadataName';
    FInstantCurrency := TInstantCurrency.Create(nil, FAttrMetadata);
!   FInstantCurrency.Value := 1.3;
  end;
  
! procedure TTestInstantCurrency.TearDown;
  begin
    FreeAndNil(FInstantCurrency);
--- 38,46 ----
    FAttrMetadata.Name := 'AttrMetadataName';
    FInstantCurrency := TInstantCurrency.Create(nil, FAttrMetadata);
!   vCurr := 1.3;
!   FInstantCurrency.Value := vCurr;
  end;
  
! procedure TestTInstantCurrency.TearDown;
  begin
    FreeAndNil(FInstantCurrency);
***************
*** 40,53 ****
  end;
  
! procedure TTestInstantCurrency.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;
--- 48,87 ----
  end;
  
! procedure TestTInstantCurrency.TestAsCurrency;
! var
!   vCurr: Currency;
! begin
!   vCurr := 23.45;
!   FInstantCurrency.AsCurrency := vCurr;
!   AssertEquals(vCurr, FInstantCurrency.Value);
!   AssertEquals(vCurr, FInstantCurrency.AsCurrency);
! end;
! 
! procedure TestTInstantCurrency.TestAsFloat;
! begin
!   FInstantCurrency.AsFloat := 89.45;
!   AssertEquals(89.45, FInstantCurrency.Value);
!   AssertEquals(89.45, FInstantCurrency.AsFloat);
! end;
! 
! procedure TestTInstantCurrency.TestAsInteger;
! begin
!   FInstantCurrency.AsInteger := 89;
!   AssertEquals(89.0, FInstantCurrency.Value);
!   AssertEquals(89.0, FInstantCurrency.AsInteger);
! end;
! 
! procedure TestTInstantCurrency.TestAssign;
  var
    vSource: TInstantCurrency;
+   vCurr: Currency;
  begin
!   AssertEquals(1.3, FInstantCurrency.Value);
    vSource := TInstantCurrency.Create;
    try
!     vCurr := 4.3;
!     VSource.Value := vCurr;
      FInstantCurrency.Assign(vSource);
!     AssertEquals(vCurr, FInstantCurrency.Value);
    finally
      vSource.Free;
***************
*** 55,91 ****
  end;
  
! procedure TTestInstantCurrency.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' + DecimalSeparator + '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 TTestInstantCurrency.TestValue;
  var
!   c: Currency;
  begin
!   c := 123456789012.12345;
!   FInstantCurrency.AsCurrency := c;
!   AssertEquals(c, FInstantCurrency.Value);
!   AssertEquals(c, FInstantCurrency.AsCurrency);
!   c := c + 0.0001;
!   AssertFalse('Precision limit', c = FInstantCurrency.Value);
!   FInstantCurrency.AsCurrency := c;
!   c := c + 0.00001;
!   AssertEquals('Out of precision limit', c, FInstantCurrency.Value);
!   c := -0.0001;
!   FInstantCurrency.AsCurrency := c;
!   AssertEquals(c, FInstantCurrency.Value);
    AssertFalse(0 = FInstantCurrency.Value);
  end;
--- 89,141 ----
  end;
  
! procedure TestTInstantCurrency.TestAsString;
  begin
!   FInstantCurrency.AsString := '15' + DecimalSeparator + '7';
!   AssertEquals(15.7, FInstantCurrency.Value);
!   AssertEquals('15' + DecimalSeparator + '7', FInstantCurrency.AsString);
! end;
! 
! procedure TestTInstantCurrency.TestAsVariant;
! begin                                           
!   FInstantCurrency.AsVariant := 15.1;
!   AssertEquals(15.1, FInstantCurrency.Value);
!   AssertEquals(15.1, FInstantCurrency.AsVariant);
! end;
! 
! procedure TestTInstantCurrency.TestReset;
! begin
!   AssertNotNull(FInstantCurrency.Metadata);
    // Metadata.DefaultValue is '';
    FInstantCurrency.Reset;
!   AssertEquals(1.3, FInstantCurrency.Value);
  
    FInstantCurrency.Metadata.DefaultValue := '15' + DecimalSeparator + '7';
    FInstantCurrency.Reset;
!   AssertEquals(15.7, FInstantCurrency.Value);
  
    FInstantCurrency.Metadata := nil;
!   AssertNull(FInstantCurrency.Metadata);
    FInstantCurrency.Reset;
!   AssertEquals(0.0, FInstantCurrency.Value);
  end;
  
! procedure TestTInstantCurrency.TestValue;
  var
!   vCurr: Currency;
  begin
!   AssertEquals(1.3, FInstantCurrency.Value);
! 
!   vCurr := 123456789012.12345;
!   FInstantCurrency.AsCurrency := vCurr;
!   AssertEquals(vCurr, FInstantCurrency.Value);
!   AssertEquals(vCurr, FInstantCurrency.AsCurrency);
!   vCurr := vCurr + 0.0001;
!   AssertFalse('Precision limit', vCurr = FInstantCurrency.Value);
!   FInstantCurrency.AsCurrency := vCurr;
!   vCurr := vCurr + 0.00001;
!   AssertEquals('Out of precision limit', vCurr, FInstantCurrency.Value);
!   vCurr := -0.0001;
!   FInstantCurrency.AsCurrency := vCurr;
!   AssertEquals(vCurr, FInstantCurrency.Value);
    AssertFalse(0 = FInstantCurrency.Value);
  end;
***************
*** 93,97 ****
  initialization
    // Register any test cases with the test runner
!   RegisterTests([TTestInstantCurrency]);
  
  end.
--- 143,150 ----
  initialization
    // Register any test cases with the test runner
! {$IFNDEF CURR_TESTS}
!   RegisterTests([TestTInstantCurrency]);
! {$ENDIF}
  
  end.
+  
\ No newline at end of file

Index: TestInstantNumeric.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantNumeric.pas,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TestInstantNumeric.pas	8 May 2005 20:18:25 -0000	1.2
--- TestInstantNumeric.pas	10 May 2005 05:31:08 -0000	1.3
***************
*** 52,61 ****
  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;
  
--- 52,61 ----
  begin
    FInstantNumeric.AsBoolean := True;
!   AssertEquals(1, FInstantNumeric.Value);
!   AssertTrue(FInstantNumeric.AsBoolean);
  
    FInstantNumeric.AsBoolean := False;
!   AssertEquals(0, FInstantNumeric.Value);
!   AssertFalse(FInstantNumeric.AsBoolean);
  end;
  
***************
*** 63,69 ****
  begin
    FInstantNumeric.AsDateTime := 12.45;
!   AssertEquals('Set AsDateTime is incorrect!', 12, FInstantNumeric.Value);
!   AssertEquals('Get AsDateTime is incorrect!', 12.0,
!     FInstantNumeric.AsDateTime);
  end;
  
--- 63,68 ----
  begin
    FInstantNumeric.AsDateTime := 12.45;
!   AssertEquals(12, FInstantNumeric.Value);
!   AssertEquals(12.0, FInstantNumeric.AsDateTime);
  end;
  
***************
*** 91,111 ****
  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 := '#,000'; //EditMask don't use ThousandSeparator var
!   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;
  
--- 90,109 ----
  begin
    FInstantNumeric.Value := 1;
!   AssertEquals('1', FInstantNumeric.DisplayText);
  
    FInstantNumeric.Metadata.EditMask := '000';
!   AssertEquals('001', FInstantNumeric.DisplayText);
  
    FInstantNumeric.Value := 1000;
    FInstantNumeric.Metadata.EditMask := '#,000'; //EditMask don't use ThousandSeparator var
!   AssertEquals('1' + ThousandSeparator + '000', FInstantNumeric.DisplayText);
  end;
  
  procedure TestTInstantNumeric.TestIsDefault;
  begin
!   AssertTrue(FInstantNumeric.IsDefault);
  
    FInstantNumeric.Value := 100;
!   AssertFalse(FInstantNumeric.IsDefault);
  end;
  

Index: TestInstantScheme.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantScheme.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantScheme.pas	3 May 2005 04:52:37 -0000	1.1
--- TestInstantScheme.pas	10 May 2005 05:31:08 -0000	1.2
***************
*** 44,51 ****
  procedure TestTInstantRelationalScheme.TestBlobStreamFormat;
  begin
!   AssertTrue('Incorrect BlobStreamFormat!',
      sfBinary = FInstantRelationalScheme.BlobStreamFormat);
    FInstantRelationalScheme.BlobStreamFormat := sfXML;
!   AssertTrue('Incorrect BlobStreamFormat!',
      sfXML = FInstantRelationalScheme.BlobStreamFormat);
  end;
--- 44,51 ----
  procedure TestTInstantRelationalScheme.TestBlobStreamFormat;
  begin
!   AssertTrue('BlobStreamFormat',
      sfBinary = FInstantRelationalScheme.BlobStreamFormat);
    FInstantRelationalScheme.BlobStreamFormat := sfXML;
!   AssertTrue('BlobStreamFormat',
      sfXML = FInstantRelationalScheme.BlobStreamFormat);
  end;
***************
*** 64,86 ****
  procedure TestTInstantRelationalScheme.TestIdDataType;
  begin
!   AssertTrue('Incorrect IdDataType!',
!     dtString = FInstantRelationalScheme.IdDataType);
    FInstantRelationalScheme.IdDataType := dtInteger;
!   AssertTrue('Incorrect IdDataType!',
!     dtInteger = FInstantRelationalScheme.IdDataType);
  end;
  
  procedure TestTInstantRelationalScheme.TestIdSize;
  begin
!   AssertEquals('Incorrect IDSize!', InstantDefaultFieldSize,
      FInstantRelationalScheme.IdSize);
    FInstantRelationalScheme.IdSize := 10;
!   AssertEquals('Incorrect IDSize!', 10, FInstantRelationalScheme.IdSize);
  end;
  
  procedure TestTInstantRelationalScheme.TestTableMetadataCount;
  begin
!   AssertEquals('Incorrect TableMetadataCount!', 8,
!     FInstantRelationalScheme.TableMetadataCount);
  end;
  
--- 64,83 ----
  procedure TestTInstantRelationalScheme.TestIdDataType;
  begin
!   AssertTrue('IdDataType', dtString = FInstantRelationalScheme.IdDataType);
    FInstantRelationalScheme.IdDataType := dtInteger;
!   AssertTrue('IdDataType', dtInteger = FInstantRelationalScheme.IdDataType);
  end;
  
  procedure TestTInstantRelationalScheme.TestIdSize;
  begin
!   AssertEquals(InstantDefaultFieldSize,
      FInstantRelationalScheme.IdSize);
    FInstantRelationalScheme.IdSize := 10;
!   AssertEquals(10, FInstantRelationalScheme.IdSize);
  end;
  
  procedure TestTInstantRelationalScheme.TestTableMetadataCount;
  begin
!   AssertEquals(8, FInstantRelationalScheme.TableMetadataCount);
  end;
  
***************
*** 90,95 ****
  begin
    vReturnValue := FInstantRelationalScheme.TableMetadatas[0];
!   AssertNotNull('TableMetadata is nil!', vReturnValue);
!   AssertEquals('', 'Address', vReturnValue.Name);
  end;
  
--- 87,92 ----
  begin
    vReturnValue := FInstantRelationalScheme.TableMetadatas[0];
!   AssertNotNull(vReturnValue);
!   AssertEquals('Address', vReturnValue.Name);
  end;
  

--- NEW FILE: TestBlobText.txt ---
The following notes document the structure of the InstantObjects tree as stored in CVS, explaining what each folder is for.

Index: TestInstantString.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantString.pas,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** TestInstantString.pas	8 May 2005 20:18:25 -0000	1.3
--- TestInstantString.pas	10 May 2005 05:31:08 -0000	1.4
***************
*** 60,80 ****
  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;
  var
!   c: Currency;
  begin
!   c := 23.45;
!   FInstantString.AsCurrency := c;
!   AssertEquals('Set AsCurrency is incorrect!', '23' + DecimalSeparator + '45', FInstantString.Value);
!   AssertEquals('Get AsCurrency is incorrect!', 23.45,
!     FInstantString.AsCurrency);
  end;
  
--- 60,79 ----
  begin
    FInstantString.AsBoolean := True;
!   AssertEquals('True', FInstantString.Value);
!   AssertTrue(FInstantString.AsBoolean);
  
    FInstantString.AsBoolean := False;
!   AssertEquals('False', FInstantString.Value);
!   AssertFalse(FInstantString.AsBoolean);
  end;
  
  procedure TestTInstantString.TestAsCurrency;
  var
!   vCurr: Currency;
  begin
!   vCurr := 23.45;
!   FInstantString.AsCurrency := vCurr;
!   AssertEquals('23' + DecimalSeparator + '45', FInstantString.Value);
!   AssertEquals(vCurr, FInstantString.AsCurrency);
  end;
  
***************
*** 82,89 ****
  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;
  
--- 81,86 ----
  begin
    FInstantString.AsDateTime := 12.45;
!   AssertEquals(DateTimeToStr(12.45), FInstantString.Value);
!   AssertEquals(12.45, FInstantString.AsDateTime);
  end;
  
***************
*** 91,96 ****
  begin
    FInstantString.AsFloat := 89.45;
!   AssertEquals('Set AsFloat is incorrect!', '89' + DecimalSeparator + '45', FInstantString.Value);
!   AssertEquals('Get AsFloat is incorrect!', 89.45, FInstantString.AsFloat);
  end;
  
--- 88,93 ----
  begin
    FInstantString.AsFloat := 89.45;
!   AssertEquals('89' + DecimalSeparator + '45', FInstantString.Value);
!   AssertEquals(89.45, FInstantString.AsFloat);
  end;
  
***************
*** 98,103 ****
  begin
    FInstantString.AsInteger := 100;
!   AssertEquals('Set AsInteger is incorrect!', '100', FInstantString.Value);
!   AssertEquals('Get AsInteger is incorrect!', 100, FInstantString.AsInteger);
  end;
  
--- 95,100 ----
  begin
    FInstantString.AsInteger := 100;
!   AssertEquals('100', FInstantString.Value);
!   AssertEquals(100, FInstantString.AsInteger);
  end;
  
***************
*** 126,131 ****
    vSource: TInstantString;
  begin
!   AssertEquals('String value is incorrect!', 'StringValue',
!     FInstantString.Value);
  
    vSource := TInstantString.Create;
--- 123,127 ----
    vSource: TInstantString;
  begin
!   AssertEquals('StringValue', FInstantString.Value);
  
    vSource := TInstantString.Create;
***************
*** 133,138 ****
      VSource.Value := 'DifferentString';
      FInstantString.Assign(vSource);
!     AssertEquals('String value is incorrect!', 'DifferentString',
!       FInstantString.Value);
    finally
      vSource.Free;
--- 129,133 ----
      VSource.Value := 'DifferentString';
      FInstantString.Assign(vSource);
!     AssertEquals('DifferentString', FInstantString.Value);
    finally
      vSource.Free;
***************
*** 143,150 ****
  begin
    FInstantString.AsString := 'DifferentString';
!   AssertEquals('Set AsString is incorrect!', 'DifferentString',
!     FInstantString.Value);
!   AssertEquals('Get AsString is incorrect!', 'DifferentString',
!     FInstantString.AsString);
  end;
  
--- 138,143 ----
  begin
    FInstantString.AsString := 'DifferentString';
!   AssertEquals('DifferentString', FInstantString.Value);
!   AssertEquals('DifferentString', FInstantString.AsString);
  end;
  
***************
*** 152,194 ****
  begin                                           
    FInstantString.AsVariant := 'DifferentString';
!   AssertEquals('Set AsVariant is incorrect!', 'DifferentString',
!     FInstantString.Value);
!   AssertEquals('Get AsVariant is incorrect!', 'DifferentString',
!     FInstantString.AsVariant);
  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;
  
--- 145,184 ----
  begin                                           
    FInstantString.AsVariant := 'DifferentString';
!   AssertEquals('DifferentString', FInstantString.Value);
!   AssertEquals('DifferentString', FInstantString.AsVariant);
  end;
  
  procedure TestTInstantString.TestName;
  begin
!   AssertEquals('AttrMetadataName', FInstantString.Name);
  end;
  
  procedure TestTInstantString.TestOwner;
  begin
!   AssertSame(FOwner, FInstantString.Owner);
  end;
  
  procedure TestTInstantString.TestReset;
  begin
!   AssertNotNull(FInstantString.Metadata);
    // Metadata.DefaultValue is '';
    FInstantString.Reset;
!   AssertEquals('', FInstantString.Value);
  
    FInstantString.Metadata.DefaultValue := '1000';
    FInstantString.Reset;
!   AssertEquals('1000', FInstantString.Value);
  
    FInstantString.Metadata := nil;
!   AssertNull(FInstantString.Metadata);
    FInstantString.Reset;
!   AssertEquals('', FInstantString.Value);
  end;
  
  procedure TestTInstantString.TestValue;
  begin
!   AssertEquals('StringValue', FInstantString.Value);
    FInstantString.Value := 'NewValue';
!   AssertEquals('NewValue', FInstantString.Value);
  end;
  
***************
*** 200,202 ****
  
  end.
!  
--- 190,192 ----
  
  end.
!  
\ No newline at end of file

Index: TestInstantInteger.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantInteger.pas,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** TestInstantInteger.pas	7 May 2005 04:59:48 -0000	1.3
--- TestInstantInteger.pas	10 May 2005 05:31:08 -0000	1.4
***************
*** 53,61 ****
  
  procedure TestTInstantInteger.TestAsCurrency;
  begin
!   FInstantInteger.AsCurrency := 23.45;
!   AssertEquals('Set AsCurrency is incorrect!', 23, FInstantInteger.Value);
!   AssertEquals('Get AsCurrency is incorrect!', 23.0,
!     FInstantInteger.AsCurrency);
  end;
  
--- 53,63 ----
  
  procedure TestTInstantInteger.TestAsCurrency;
+ var
+   vCurr: Currency;
  begin
!   vCurr := 23.45;
!   FInstantInteger.AsCurrency := vCurr;
!   AssertEquals(23, FInstantInteger.Value);
!   AssertEquals(23.0, FInstantInteger.AsCurrency);
  end;
  
***************
*** 63,68 ****
  begin
    FInstantInteger.AsFloat := 89.45;
!   AssertEquals('Set AsFloat is incorrect!', 89, FInstantInteger.Value);
!   AssertEquals('Get AsFloat is incorrect!', 89.0, FInstantInteger.AsFloat);
  end;
  
--- 65,70 ----
  begin
    FInstantInteger.AsFloat := 89.4...
 
[truncated message content]