[Instantobjects-cvscommit] Source/Tests TestInstantPart.pas,NONE,1.1 TestInstantElement.pas,NONE,1.1 TestInstantComplex.pas,NONE,1.1 TestIO.dpr,1.10,1.11 TestInstantBlob.pas,1.1,1.2

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

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

Modified Files:
	TestIO.dpr TestInstantBlob.pas 
Added Files:
	TestInstantPart.pas TestInstantElement.pas 
	TestInstantComplex.pas 
Log Message:
Added tests for TInstantComplex, Element and Part classes. Trivial 
tidy up for TestInstantBlob code.

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

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantPart
  TestTInstantPart = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantPart: TInstantPart;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAssign;
    procedure TestAllowOwned;
    procedure TestIsChanged;
    procedure TestIsDefault;
    procedure TestHasValue;
    procedure TestUnchanged;
    procedure TestValue_Reset;
  end;

implementation

uses SysUtils, testregistry;

procedure TestTInstantPart.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantPart;
  FAttrMetadata.StorageKind := skExternal;
  FInstantPart := TInstantPart.Create(FOwner, FAttrMetadata);
end;

procedure TestTInstantPart.TearDown;
begin
  FreeAndNil(FInstantPart);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

procedure TestTInstantPart.TestAssign;
var
  vSource: TInstantPart;
  vAttrMetadata: TInstantAttributeMetadata;
  vPart: TInstantObject;
begin
  vAttrMetadata := TInstantAttributeMetadata.Create(nil);
  vAttrMetadata.AttributeClass := TInstantPart;
  vSource := TInstantPart.Create(FOwner, vAttrMetadata);
  try
    vPart := TInstantObject.Create(FConn);
    vSource.Value := vPart;
    AssertTrue(vSource.HasValue);

    AssertFalse(FInstantPart.HasValue);
    FInstantPart.Assign(vSource);
    AssertTrue(FInstantPart.HasValue);
    AssertNotSame(vSource, FInstantPart.Value);
  finally
    vSource.Free;
  end;
end;

procedure TestTInstantPart.TestAllowOwned;
begin
  AssertTrue(FInstantPart.AllowOwned);
end;

procedure TestTInstantPart.TestIsChanged;
var
  vPart: TInstantObject;
begin
  AssertFalse(FInstantPart.IsChanged);

  vPart := TInstantObject.Create(FConn);
  vPart.Changed;
  FInstantPart.Value := vPart;
  AssertTrue(FInstantPart.IsChanged);
end;

procedure TestTInstantPart.TestIsDefault;
var
  vPart: TInstantObject;
begin
  AssertTrue(FInstantPart.IsDefault);

  vPart := TInstantObject.Create(FConn);
  vPart.Id := 'PartId';
  FInstantPart.Value := vPart;
  AssertFalse(FInstantPart.IsDefault);
end;

procedure TestTInstantPart.TestHasValue;
begin
  AssertFalse(FInstantPart.HasValue);

  FInstantPart.Value := TInstantObject.Create(FConn);
  AssertTrue(FInstantPart.HasValue);
end;

procedure TestTInstantPart.TestUnchanged;
begin
  FInstantPart.Changed;
  AssertTrue(FInstantPart.IsChanged);
  FInstantPart.Unchanged;
  AssertFalse(FInstantPart.IsChanged);
end;

procedure TestTInstantPart.TestValue_Reset;
var
  vFirstObj: TInstantObject;
  vSecondObj: TInstantObject;
begin
  AssertFalse(FInstantPart.HasValue);
  AssertNotNull(FInstantPart.Value);
  AssertTrue(FInstantPart.HasValue);
  vFirstObj := FInstantPart.Value;

  vSecondObj := TInstantObject.Create(FConn);
  vSecondObj.Id := 'PartId';
  FInstantPart.Value := vSecondObj;
  AssertEquals('PartId', FInstantPart.Value.Id);
  AssertNotSame(vFirstObj, FInstantPart.Value);

  FInstantPart.Reset;
  AssertFalse(FInstantPart.HasValue);
end;

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

end.
 
Index: TestInstantBlob.pas
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestInstantBlob.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestInstantBlob.pas	10 May 2005 05:31:08 -0000	1.1
--- TestInstantBlob.pas	14 May 2005 07:38:36 -0000	1.2
***************
*** 33,39 ****
  procedure TestTInstantBlob.SetUp;
  begin
- //  FConn := TInstantMockConnector.Create(nil);
- //  FConn.BrokerClass := TInstantMockBroker;
- //  FOwner := TInstantObject.Create(FConn);
    FAttrMetadata := TInstantAttributeMetadata.Create(nil);
    FAttrMetadata.AttributeClass := TInstantBlob;
--- 33,36 ----
***************
*** 46,51 ****
    FreeAndNil(FInstantBlob);
    FreeAndNil(FAttrMetadata);
- //  FreeAndNil(FOwner);
- //  FreeAndNil(FConn);
  end;
  
--- 43,46 ----
***************
*** 233,237 ****
  end;
  
- 
  initialization
    // Register any test cases with the test runner
--- 228,231 ----

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

interface

uses fpcunit, InstantPersistence;

type

  // Test methods for class TInstantComplex
  TestTInstantComplex = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FInstantComplex: TInstantComplex;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAllowOwned;
    procedure TestAttachObject;
    procedure TestConnector;
    procedure TestDetachObject;
    procedure TestRequiredClass;
    procedure TestRequiredClassName;
  end;

implementation

uses SysUtils, testregistry;

procedure TestTInstantComplex.SetUp;
begin
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantComplex;
  FAttrMetadata.Name := 'AttrMetadataName';
  FInstantComplex := TInstantComplex.Create(nil, FAttrMetadata);
end;

procedure TestTInstantComplex.TearDown;
begin
  FreeAndNil(FInstantComplex);
  FreeAndNil(FAttrMetadata);
end;

procedure TestTInstantComplex.TestAllowOwned;
begin
  AssertFalse(FInstantComplex.AllowOwned);
end;

procedure TestTInstantComplex.TestAttachObject;
begin
  AssertFalse(FInstantComplex.AttachObject(nil));
end;

procedure TestTInstantComplex.TestConnector;
begin
  AssertNotNull(FInstantComplex.Connector);
end;

procedure TestTInstantComplex.TestDetachObject;
begin
  AssertFalse(FInstantComplex.DetachObject(nil));
end;

procedure TestTInstantComplex.TestRequiredClass;
begin
  AssertEquals(TInstantObject, FInstantComplex.RequiredClass);
end;

procedure TestTInstantComplex.TestRequiredClassName;
begin
  AssertEquals('', FInstantComplex.RequiredClassName);
  FAttrMetadata.ObjectClassName := 'TInstantObject';
  AssertEquals('TInstantObject', FInstantComplex.RequiredClassName);
end;

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

end.
 
Index: TestIO.dpr
===================================================================
RCS file: /cvsroot/instantobjects/Source/Tests/TestIO.dpr,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** TestIO.dpr	10 May 2005 05:31:08 -0000	1.10
--- TestIO.dpr	14 May 2005 07:38:36 -0000	1.11
***************
*** 38,42 ****
    TestInstantFloat in 'TestInstantFloat.pas',
    TestInstantCurrency in 'TestInstantCurrency.pas',
!   TestInstantBlob in 'TestInstantBlob.pas';
  
  {$R *.res}
--- 38,45 ----
    TestInstantFloat in 'TestInstantFloat.pas',
    TestInstantCurrency in 'TestInstantCurrency.pas',
!   TestInstantBlob in 'TestInstantBlob.pas',
!   TestInstantComplex in 'TestInstantComplex.pas',
!   TestInstantElement in 'TestInstantElement.pas',
!   TestInstantPart in 'TestInstantPart.pas';
  
  {$R *.res}

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

interface

uses fpcunit, InstantPersistence, InstantMock;

type

  // Test methods for class TInstantElement
  TestTInstantElement = class(TTestCase)
  private
    FAttrMetadata: TInstantAttributeMetadata;
    FConn: TInstantMockConnector;
    FInstantElement: TInstantElement;
    FOwner: TInstantObject;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAttach_DetachObject;
    procedure TestHasValue;
    procedure TestSaveObjectTo_FromStream;
  end;

implementation

uses SysUtils, Classes, InstantClasses, testregistry;

procedure TestTInstantElement.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;
  FOwner := TInstantObject.Create(FConn);
  FAttrMetadata := TInstantAttributeMetadata.Create(nil);
  FAttrMetadata.AttributeClass := TInstantPart;
  FInstantElement := TInstantPart.Create(FOwner, FAttrMetadata);
end;

procedure TestTInstantElement.TearDown;
begin
  FreeAndNil(FInstantElement);
  FreeAndNil(FAttrMetadata);
  FreeAndNil(FOwner);
  FreeAndNil(FConn);
end;

procedure TestTInstantElement.TestAttach_DetachObject;
var
  vReturnValue: Boolean;
  vObject: TInstantObject;
begin
  vObject := TInstantObject.Create(FConn);
  vObject.Id := 'Object.Id';
  AssertNotNull('vObject', vObject);
  vReturnValue := FInstantElement.AttachObject(vObject);
  AssertTrue('AttachObject', vReturnValue);
  AssertSame(vObject, FInstantElement.Value);
  AssertTrue(FInstantElement.HasValue);

  // ToDo: Why does this return false?
  vReturnValue := FInstantElement.DetachObject(vObject);
  AssertTrue('DetachObject', vReturnValue);  // Fails??
end;

procedure TestTInstantElement.TestHasValue;
begin
  AssertFalse(FInstantElement.HasValue);
end;

procedure TestTInstantElement.TestSaveObjectTo_FromStream;
var
  vObject: TInstantObject;
  vReturnValue: Boolean;
  vStream: TStream;
begin
  vObject := TInstantObject.Create(FConn);
  AssertNotNull('Create object', vObject);
  vReturnValue := FInstantElement.AttachObject(vObject);
  AssertTrue('AttachObject', vReturnValue);
  AssertTrue(FInstantElement.HasValue);

  vStream := TInstantStream.Create;
  try
    FInstantElement.SaveObjectToStream(vStream);
    AssertTrue('vStream.Size check', vStream.Size > 0);
    FInstantElement.Value := nil;
    AssertFalse(FInstantElement.HasValue);
    vStream.Position := 0;
    FInstantElement.LoadObjectFromStream(vStream);
    AssertTrue(FInstantElement.HasValue);
  finally
    vStream.Free;
  end;
end;

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

end.