[Instantobjects-cvscommit] Source/Tests TestInstantObject.pas,NONE,1.1 TestInstantReference.pas,NONE,1.1

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

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

Added Files:
	TestInstantObject.pas TestInstantReference.pas 
Log Message:
Update to tests

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

interface

uses fpcunit, InstantPersistence, InstantMock, TestModel;

type

  // Test methods for class TInstantObject
  TestTInstantObject = class(TTestCase)
  private
    FConn: TInstantMockConnector;
    FInstantObject: TPerson;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestObjectsArrayMethods;
    procedure TestAddRef_Release;
    procedure TestAssign_Clone_ResetAttributes;
    procedure TestAttributeByName;
    procedure TestCanDispose;
    procedure TestCanStore;
    procedure TestChanged_Unchanged_IsChanged;
    procedure TestChangesDisabled_EnableDisableChanges;
    procedure TestCheckId;
    procedure TestClassType;
    procedure TestContainerByName;
    procedure TestEqualsSignature;
    procedure TestEqualsPersistentSignature;
    procedure TestFindAttribute;
    procedure TestFindContainer;
    procedure TestFreeInstance;
    procedure TestGetNamePath;
    procedure TestHasDefaultContainer;
    procedure TestIsAbandoned;
    procedure TestIsDefault;
    procedure TestIsIdChanged;
    // ToDo: procedure TestInvoke;
    procedure TestIsOperationAllowed;
    procedure TestIsOwned;
    procedure TestIsPersistent;
    procedure TestMetadata;
    procedure TestNewInstance;
    procedure TestObjectChangeCount;
    procedure TestObjectClass;
    procedure TestOwner;
    procedure TestOwnerAttribute;
    procedure TestPersistentId;
    procedure TestRefresh_RefreshAll;
    procedure TestStore_Dispose;
    procedure TestUpdateCount;
  end;

implementation

uses SysUtils, Classes, Db, InstantClasses, testregistry;

procedure TestTInstantObject.SetUp;
var
  vInstantClassMetadata: TInstantClassMetadata;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;

  if InstantModel.ClassMetadatas.Count > 0 then
    InstantModel.ClassMetadatas.Clear;

  InstantModel.LoadFromResFile(ChangeFileExt(ParamStr(0), '.mdr'));
  vInstantClassMetadata := InstantModel.ClassMetadatas.Find('TPerson');
  vInstantClassMetadata.DefaultContainerName := 'Emails';
  FInstantObject := TPerson.Create(FConn);
  FInstantObject.Name := 'InitPerson';
end;

procedure TestTInstantObject.TearDown;
begin
  FreeAndNil(FInstantObject);
  InstantModel.ClassMetadatas.Clear;
  FreeAndNil(FConn);
end;

procedure TestTInstantObject.TestObjectsArrayMethods;
var
  vReturnValue: Integer;
  vObject: TEmail;
begin
  vObject := TEmail.Create(FConn);
  AssertNotNull(vObject);
  vObject.Address := 'Object1';
  vReturnValue := FInstantObject.AddObject(vObject);
  AssertEquals('vReturnValue', 0, vReturnValue);
  AssertEquals('ObjectCount 1', 1, FInstantObject.ObjectCount);

  vObject := TEmail.Create(FConn);
  AssertNotNull(vObject);
  vObject.Address := 'Object2';
  vReturnValue := FInstantObject.AddObject(vObject);
  AssertEquals('vReturnValue', 1, vReturnValue);
  AssertEquals('ObjectCount 2', 2, FInstantObject.ObjectCount);

  AssertEquals('Object Index', 1, FInstantObject.IndexOfObject(vObject));

  vObject := TEmail.Create(FConn);
  AssertNotNull(vObject);
  vObject.Address := 'Object3';
  vReturnValue := FInstantObject.AddObject(vObject);
  AssertEquals('vReturnValue', 2, vReturnValue);
  AssertEquals('ObjectCount 3', 3, FInstantObject.ObjectCount);

  vObject := TEmail.Create(FConn);
  AssertNotNull(vObject);
  vObject.Address := 'Object4';
  FInstantObject.InsertObject(2, vObject);
  AssertEquals('ObjectCount 4', 4, FInstantObject.ObjectCount);

  FInstantObject.DeleteObject(1);
  AssertEquals('ObjectCount 5', 3, FInstantObject.ObjectCount);
  AssertEquals('Address 1', 'Object1',
    TEmail(FInstantObject.Objects[0]).Address);
  AssertEquals('Address 2', 'Object4',
    TEmail(FInstantObject.Objects[1]).Address);
  AssertEquals('Address 3', 'Object3',
    TEmail(FInstantObject.Objects[2]).Address);

  FInstantObject.ClearObjects;
  AssertEquals('ObjectCount 6', 0, FInstantObject.ObjectCount);
end;

procedure TestTInstantObject.TestAddRef_Release;
var
  vReturnValue: Integer;
begin
  AssertEquals('RefCount 1', 1, FInstantObject.RefCount);
  vReturnValue := FInstantObject.AddRef;
  AssertEquals('RefCount 2', 2, vReturnValue);
  vReturnValue := FInstantObject.Release;
  AssertEquals('RefCount 3', 1, vReturnValue);
end;

procedure TestTInstantObject.TestAssign_Clone_ResetAttributes;
var
  vCompany: TCompany;
  vEmail: TEmail;
  vSource, vClone: TPerson;
begin
  vCompany := nil;
  vClone := nil;

  vSource := TPerson.Create(FConn);
  try
    AssertNotNull(vSource);
    vSource.Name := 'NewPerson';
    vEmail := TEmail.Create(FConn);
    vEmail.Address := 'New...@do...';
    vSource.AddEmail(vEmail);
    vCompany := TCompany.Create(FConn);
    vCompany.Name := 'Employer Co.';
    vSource.EmployBy(vCompany);

    AssertEquals('InitPerson', FInstantObject.Name);
    FInstantObject.Assign(vSource);
    AssertEquals('NewPerson', FInstantObject.Name);
    AssertEquals(1, FInstantObject.EmailCount);
    AssertEquals('New...@do...', FInstantObject.Emails[0].Address);
    AssertEquals('Employer Co.', FInstantObject.Employer.Name);

    vClone := TPerson(FInstantObject.Clone(FConn));
    AssertNotNull(vClone);
    AssertNotSame(vClone, FInstantObject);
    AssertEquals('NewPerson', vClone.Name);
    AssertEquals(1, vClone.EmailCount);
    AssertEquals('New...@do...', vClone.Emails[0].Address);
    AssertEquals('Employer Co.', vClone.Employer.Name);

    FInstantObject.ResetAttributes;
    AssertEquals('', FInstantObject.Name);
    AssertEquals(0, FInstantObject.EmailCount);
    AssertNull(FInstantObject.Employer);
  finally
    vCompany.ClearEmployees;
    vCompany.Free;
    vSource.Free;
    vClone.Free;
  end;
end;

procedure TestTInstantObject.TestAttributeByName;
var
  vReturnValue: TInstantAttribute;
begin
  vReturnValue := FInstantObject.AttributeByName('Name');
  AssertNotNull('Name', vReturnValue);
  AssertEquals('Name', 'InitPerson', vReturnValue.Value);
  vReturnValue := FInstantObject.AttributeByName('Employer');
  AssertNotNull('Employer', vReturnValue);
  AssertEquals('Employer', 'Employer', vReturnValue.Name);

  try
    FInstantObject.AttributeByName('Dummy');
    Fail('Should never get here!!');
  except
    on E: EInstantError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantObject.TestCanDispose;
begin
  AssertTrue(FInstantObject.CanDispose);
end;

procedure TestTInstantObject.TestCanStore;
begin
  AssertTrue(FInstantObject.CanStore);
end;

procedure TestTInstantObject.TestChanged_Unchanged_IsChanged;
begin
  AssertTrue(FInstantObject.IsChanged);
  FInstantObject.Unchanged;
  AssertFalse(FInstantObject.IsChanged);
end;

procedure TestTInstantObject.TestChangesDisabled_EnableDisableChanges;
begin
  AssertFalse(FInstantObject.ChangesDisabled);
  FInstantObject.DisableChanges;
  AssertTrue(FInstantObject.ChangesDisabled);
  FInstantObject.DisableChanges;
  AssertTrue(FInstantObject.ChangesDisabled);
  FInstantObject.EnableChanges;
  AssertTrue(FInstantObject.ChangesDisabled);
  FInstantObject.EnableChanges;
  AssertFalse(FInstantObject.ChangesDisabled);
end;

procedure TestTInstantObject.TestCheckId;
begin
  FInstantObject.CheckId;
  AssertFalse(FInstantObject.Id = '');
  FInstantObject.Id := 'PersonId';
  FInstantObject.CheckId;
  AssertEquals('PersonId', FInstantObject.Id);
end;

procedure TestTInstantObject.TestClassType;
begin
  AssertEquals(TPerson, FInstantObject.ClassType);
end;

procedure TestTInstantObject.TestContainerByName;
var
  vReturnValue: TInstantContainer;
begin
  // Get DefaultContainer name
  vReturnValue := FInstantObject.ContainerByName('');
  AssertNotNull(vReturnValue);
  AssertEquals('Emails', vReturnValue.Name);

  vReturnValue := FInstantObject.ContainerByName('Emails');
  AssertNotNull(vReturnValue);

  try
    FInstantObject.ContainerByName('Dummy');
    Fail('Should never get here!!');
  except
    on E: EInstantError do ; // do nothing as this is expected
    else
      raise;
  end;
end;

procedure TestTInstantObject.TestEqualsPersistentSignature;
var
  vReturnValue: Boolean;
  vObjectId: string;
  vObjectClassName: string;
begin
  vObjectId := 'PersonID';
  vObjectClassName := 'TPerson';
  FInstantObject.Id := 'PersonID';
  AssertFalse('IsPersistent', FInstantObject.IsPersistent);
  vReturnValue :=
    FInstantObject.EqualsPersistentSignature(vObjectClassName, vObjectId);
  AssertFalse('EqualsPersistentSignature', vReturnValue);

  FInstantObject.Store;
  vReturnValue :=
    FInstantObject.EqualsPersistentSignature(vObjectClassName, vObjectId);
  AssertTrue('EqualsPersistentSignature', vReturnValue);
end;

procedure TestTInstantObject.TestEqualsSignature;
var
  vReturnValue: Boolean;
  vObjectId: string;
  vObjectClassName: string;
begin
  vObjectId := 'PersonID';
  vObjectClassName := 'TPerson';
  FInstantObject.Id := 'PersonID';
  vReturnValue := FInstantObject.EqualsSignature(vObjectClassName, vObjectId);
  AssertTrue('EqualsSignature', vReturnValue);
end;

procedure TestTInstantObject.TestFindAttribute;
var
  vReturnValue: TInstantAttribute;
begin
  vReturnValue := FInstantObject.FindAttribute('Name');
  AssertNotNull('Name', vReturnValue);
  AssertEquals('InitPerson', vReturnValue.Value);
  vReturnValue := FInstantObject.FindAttribute('Employer');
  AssertNotNull('Employer', vReturnValue);
  AssertEquals('Employer', 'Employer', vReturnValue.Name);
end;

procedure TestTInstantObject.TestFindContainer;
var
  vReturnValue: TInstantContainer;
begin
  // Get DefaultContainer name
  vReturnValue := FInstantObject.FindContainer('');
  AssertNotNull(vReturnValue);
  AssertEquals('Emails', vReturnValue.Name);

  vReturnValue := FInstantObject.FindContainer('Emails');
  AssertNotNull(vReturnValue);

  vReturnValue := FInstantObject.FindContainer('Dummy');
  AssertNull(vReturnValue);
end;

procedure TestTInstantObject.TestFreeInstance;
begin
  FInstantObject.FreeInstance;
  FInstantObject := nil;
  AssertNull(FInstantObject);
end;

procedure TestTInstantObject.TestGetNamePath;
begin
  FInstantObject.Id := 'PersonID';
  AssertEquals('TPerson.PersonID', FInstantObject.GetNamePath);
end;

procedure TestTInstantObject.TestHasDefaultContainer;
begin
  AssertTrue(FInstantObject.HasDefaultContainer);
end;

procedure TestTInstantObject.TestIsAbandoned;
begin
  AssertFalse(FInstantObject.IsAbandoned);
end;

procedure TestTInstantObject.TestIsDefault;
begin
  AssertFalse(FInstantObject.IsDefault);
  FInstantObject.ResetAttributes;
  FInstantObject.Id := '';
  AssertTrue('After ResetAttributes', FInstantObject.IsDefault);
end;

procedure TestTInstantObject.TestIsIdChanged;
begin
  AssertTrue('Initial', FInstantObject.IsIdChanged);
  FInstantObject.Store;
  AssertFalse('After store', FInstantObject.IsIdChanged);
  FInstantObject.Id := 'PersonId';
  AssertTrue('After change ID', FInstantObject.IsIdChanged);
  FInstantObject.Store;
  AssertFalse('After changed store', FInstantObject.IsIdChanged);
end;

procedure TestTInstantObject.TestIsOperationAllowed;
var
  vOT: TInstantOperationType;
begin
  for vOT := Low(TInstantOperationType) to High(TInstantOperationType) do
    AssertTrue(FInstantObject.IsOperationAllowed(vOT));
end;

procedure TestTInstantObject.TestIsOwned;
begin
  AssertFalse('TPerson', FInstantObject.IsOwned);
end;

procedure TestTInstantObject.TestIsPersistent;
begin
  AssertFalse(FInstantObject.IsPersistent);
end;

procedure TestTInstantObject.TestMetadata;
var
  vReturnValue: TInstantClassMetadata;
begin
  vReturnValue := FInstantObject.Metadata;
  AssertNotNull(vReturnValue);
  AssertEquals('TPerson', FInstantObject.Metadata.Name);
end;

procedure TestTInstantObject.TestNewInstance;
var
  vReturnValue: TObject;
begin
  vReturnValue := FInstantObject.NewInstance;
  AssertNotNull(vReturnValue);
  AssertEquals('InstanceSize', TPerson.InstanceSize, vReturnValue.InstanceSize);
end;

procedure TestTInstantObject.TestObjectChangeCount;
var
  vReturnValue: Integer;
  vObject: TEmail;
begin
  AssertEquals(0, FInstantObject.ObjectChangeCount);

  vObject := TEmail.Create(FConn);
  AssertNotNull(vObject);
  vObject.Address := 'Object1';
  vReturnValue := FInstantObject.AddObject(vObject);
  AssertEquals('vReturnValue', 0, vReturnValue);
  AssertEquals(1, FInstantObject.ObjectChangeCount);
end;

procedure TestTInstantObject.TestObjectClass;
begin
  AssertEquals(TEmail, FInstantObject.ObjectClass);
end;

procedure TestTInstantObject.TestOwner;
begin
  AssertTrue(FInstantObject.Owner = nil);
end;

procedure TestTInstantObject.TestOwnerAttribute;
begin
  AssertTrue(FInstantObject.OwnerAttribute = nil);
end;

procedure TestTInstantObject.TestPersistentId;
begin
  AssertEquals('', FInstantObject.PersistentId);
  FInstantObject.Store;
  AssertTrue(FInstantObject.Id <> '');
end;

procedure TestTInstantObject.TestRefresh_RefreshAll;
var
  vID: String;
  brok: TInstantMockBroker;
begin
  FConn.StartTransaction;
  brok := FConn.Broker as TInstantMockBroker;
  brok.MockManager.StartSetUp;
  FInstantObject.Store;
  vID := FInstantObject.Id;
  brok.MockManager.EndSetUp;
  brok.MockManager.AddExpectation('InternalStoreObject ' + vID);
  brok.MockManager.Verify;
  FConn.CommitTransaction;

  brok.MockManager.StartSetUp;
  FInstantObject.Refresh;
  brok.MockManager.EndSetUp;
  brok.MockManager.AddExpectation('InternalRetrieveObject ' + vID);
  brok.MockManager.Verify;

  brok.MockManager.StartSetUp;
  FInstantObject.RefreshAll(FConn, nil);
  brok.MockManager.EndSetUp;
  brok.MockManager.AddExpectation('InternalRetrieveObject ' + vID);
  brok.MockManager.Verify;
end;

procedure TestTInstantObject.TestStore_Dispose;
var
  vPhone: TPhone;
  vAddress: TAddress;
  vContact: TContact;
  vID, vID1: String;
  brok: TInstantMockBroker;
  vRet: Integer;
begin
  AssertFalse(FInstantObject.IsPersistent);
  FInstantObject.Store;
  AssertTrue(FInstantObject.IsPersistent);

  FInstantObject.Dispose;
  AssertFalse(FInstantObject.IsPersistent);

  vContact := TContact.Create(FConn);
  vAddress := TAddress.Create(FConn);
  try
    FConn.StartTransaction;
    brok := FConn.Broker as TInstantMockBroker;
    brok.MockManager.StartSetUp;
    vContact.Name := 'MyContact';
    vAddress.City := 'New York';
    AssertTrue(vAddress.IsChanged);
    vAddress.Store;
    vID1 := vAddress.Id;
    vContact.AddressExt := vAddress;
    AssertEquals('vAddress', 1, vAddress.RefCount);
    AssertEquals('vContact.Address', 1, vContact.Address.RefCount);

    vPhone := TPhone.Create(FConn);
    vPhone.Name := 'Home';
    vRet := vContact.AddPhone(vPhone);
    AssertEquals('vRet 1', 0, vRet);
    vPhone := TPhone.Create(FConn);
    vPhone.Name := 'Work';
    vRet := vContact.AddPhone(vPhone);
    AssertEquals('vRet 2', 1, vRet);

    vContact.Store;
    vPhone.Store;
    AssertTrue('vContact.IsPersistent', vContact.IsPersistent);
    AssertFalse('vPhone.IsPersistent', vPhone.IsPersistent);
    AssertTrue('vAddress.IsPersistent', vAddress.IsPersistent);
    vAddress.City := 'London';
    AssertTrue(vAddress.IsChanged);
    AssertTrue(vContact.IsChanged);
    vID := vContact.Id;
    vContact.Store;
    brok.MockManager.EndSetUp;
    brok.MockManager.AddExpectation('InternalStoreObject ' + vID1);
    brok.MockManager.AddExpectation('InternalStoreObject ' + vID);
    brok.MockManager.AddExpectation('InternalStoreObject ' + vID);
    brok.MockManager.Verify;
    FConn.CommitTransaction;

    brok.MockManager.StartSetUp;
    vContact.Phones[0].Number := '1234567';
    AssertTrue(vContact.IsChanged);
    vContact.Store;
    vContact.Dispose;
    brok.MockManager.EndSetUp;
    brok.MockManager.AddExpectation('InternalStoreObject ' + vID);
    brok.MockManager.AddExpectation('InternalDisposeObject ' + vID);
    brok.MockManager.Verify;
  finally
    vContact.Free;
  end;
end;

procedure TestTInstantObject.TestUpdateCount;
begin
  AssertEquals(0, FInstantObject.UpdateCount);
end;

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

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

interface

uses fpcunit, InstantPersistence, InstantMock, TestModel;

type

  // Test methods for class TInstantReference
  TestTInstantReference = class(TTestCase)
  private
    FConn: TInstantMockConnector;
    FInstantReference: TInstantReference;
    FOwner: TContact;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestAssign;
    procedure TestDestroyObject_HasReference_HasValue;
    procedure TestLoadObjectFromStream;
    procedure TestObjectClass_ObjectClassName_ObjectId;
    procedure TestReferenceObject;
    procedure TestReferenceObject1;
    procedure TestReset;
  end;

implementation

uses SysUtils, Classes, InstantClasses, testregistry;

procedure TestTInstantReference.SetUp;
begin
  FConn := TInstantMockConnector.Create(nil);
  FConn.BrokerClass := TInstantMockBroker;

  if InstantModel.ClassMetadatas.Count > 0 then
    InstantModel.ClassMetadatas.Clear;
  InstantModel.LoadFromResFile(ChangeFileExt(ParamStr(0), '.mdr'));

  FOwner := TContact.Create(FConn);
  FInstantReference := FOwner._Category;
end;

procedure TestTInstantReference.TearDown;
begin
  FInstantReference := nil;
  FreeAndNil(FOwner);
  InstantModel.ClassMetadatas.Clear;
  FreeAndNil(FConn);
end;

procedure TestTInstantReference.TestAssign;
var
  vSource: TInstantReference;
  vAttrMetadata: TInstantAttributeMetadata;
  vPart: TCategory;
begin
  vPart := nil; 

  vAttrMetadata := TInstantAttributeMetadata.Create(nil);
  vAttrMetadata.AttributeClass := TInstantReference;
  vSource := TInstantReference.Create(FOwner, vAttrMetadata);
  try
    vPart := TCategory.Create(FConn);
    FInstantReference.Value := vPart;
    AssertTrue('Value HasVal', FInstantReference.HasValue);

    AssertFalse('vSource HasVal', vSource.HasValue);
    vSource.Assign(FInstantReference);
    AssertTrue('Assign HasVal', vSource.HasValue);
    AssertNotSame(vSource, FInstantReference.Value);
  finally
    vPart.Free;
    vSource.Free;
    vAttrMetadata.Free;
  end;
end;

procedure TestTInstantReference.TestDestroyObject_HasReference_HasValue;
var
  vObj: TCategory;
begin
  AssertTrue('Initial HasRef', FInstantReference.HasReference);
  AssertFalse('Initial HasVal', FInstantReference.HasValue);

  vObj := TCategory.Create(FConn);
  try
    FInstantReference.Value := vObj;
    AssertTrue('Value HasRef', FInstantReference.HasReference);
    AssertTrue('Value HasVal', FInstantReference.HasValue);
    AssertSame(vObj, FInstantReference.Value);

    FInstantReference.DestroyObject;
    AssertFalse('DestroyObject HasVal', FInstantReference.HasValue);
    AssertFalse('DestroyObject HasRef', FInstantReference.HasReference);
  finally
    vObj.Free;
  end;
end;

procedure TestTInstantReference.TestLoadObjectFromStream;
var
  vObject: TCategory;
  vReturnValue: Boolean;
  vStream: TStream;
begin
  vObject := TCategory.Create(FConn);
  try
    AssertNotNull('Create object', vObject);
    AssertEquals('Object RefCount 1', 1, vObject.RefCount);
    vReturnValue := FInstantReference.AttachObject(vObject);
    AssertTrue('AttachObject', vReturnValue);
    AssertTrue('AttachObject HasVal', FInstantReference.HasValue);
    AssertTrue('AttachObject HasRef', FInstantReference.HasReference);
    AssertEquals('Object RefCount 2', 2, vObject.RefCount);

    vStream := TInstantStream.Create;
    try
      FInstantReference.SaveObjectToStream(vStream);
      AssertTrue('vStream.Size check', vStream.Size > 0);
      FInstantReference.Value := nil;
      AssertEquals('Object RefCount 3', 1, vObject.RefCount);
      AssertFalse('Value HasVal', FInstantReference.HasValue);
      AssertFalse('Value HasRef', FInstantReference.HasReference);

      vStream.Position := 0;
      FInstantReference.LoadObjectFromStream(vStream);
      AssertTrue('LoadObjectFromStream HasVal', FInstantReference.HasValue);
      AssertTrue('LoadObjectFromStream HasRef', FInstantReference.HasReference);
      AssertEquals('Object RefCount 4', 1, vObject.RefCount);
    finally
      vStream.Free;
    end;
  finally
    vObject.Free;
  end;
end;

procedure TestTInstantReference.TestObjectClass_ObjectClassName_ObjectId;
var
  vObject: TCategory;
  vReturnValue: Boolean;
begin
  vObject := TCategory.Create(FConn);
  try
    AssertNotNull('Create object', vObject);
    vObject.Id := 'Object.Id';
    vReturnValue := FInstantReference.AttachObject(vObject);
    AssertTrue('AttachObject', vReturnValue);

    AssertEquals('ObjectClass', TCategory, FInstantReference.ObjectClass);
    AssertEquals('ObjectClassName', 'TCategory', FInstantReference.ObjectClassName);
    AssertEquals('ObjectId', 'Object.Id', FInstantReference.ObjectId);
  finally
    vObject.Free;
  end;
end;

procedure TestTInstantReference.TestReferenceObject;
var
  vObjectId: string;
  vObjectClass: TInstantObjectClass;
begin
  AssertTrue('Initial HasRef', FInstantReference.HasReference);
  AssertFalse('Initial HasVal', FInstantReference.HasValue);

  vObjectId := 'ObjectId';
  vObjectClass := TCategory;
  FInstantReference.ReferenceObject(vObjectClass, vObjectId);
  AssertTrue('Final HasRef', FInstantReference.HasReference);
  AssertFalse('Final HasVal', FInstantReference.HasValue);
end;

procedure TestTInstantReference.TestReferenceObject1;
var
  vObjectId: string;
  vObjectClassName: string;
begin
  AssertTrue('Initial HasRef', FInstantReference.HasReference);
  AssertFalse('Initial HasVal', FInstantReference.HasValue);

  vObjectId := 'ObjectId';
  vObjectClassName := 'TCategory';
  FInstantReference.ReferenceObject(vObjectClassName, vObjectId);
  AssertTrue('Final HasRef', FInstantReference.HasReference);
  AssertFalse('Final HasVal', FInstantReference.HasValue);
end;

procedure TestTInstantReference.TestReset;
var
  vObj: TCategory;
begin
  AssertTrue('Initial HasRef', FInstantReference.HasReference);
  AssertFalse('Initial HasVal', FInstantReference.HasValue);

  vObj := TCategory.Create(FConn);
  try
    FInstantReference.Value := vObj;
    AssertTrue(FInstantReference.HasReference);
    AssertTrue(FInstantReference.HasValue);
    AssertSame(vObj, FInstantReference.Value);

    FInstantReference.Reset;
    AssertFalse('Final HasRef', FInstantReference.HasReference);
    AssertFalse('Final HasVal', FInstantReference.HasValue);
  finally
    vObj.Free;
  end;
end;

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

end.