void TestDehollowficationFromDatabaseOfTwoPointers(void)
{
CIndexedConfig cConfig;
CFileUtil cFileUtil;
cConfig.Manual("Output\\Dehollowfication\\Database",
FALSE,
TRUE,
FALSE,
1 MB);
cFileUtil.RemoveDir("Output\\Dehollowfication\\Database");
MemoryInit();
ObjectsInit(&cConfig);
SetupDehollowficationScene();
gcObjects.Flush(FALSE, FALSE);
ObjectsKill();
MemoryKill();
MemoryInit();
ObjectsInit(&cConfig);
SetupDehollowficationConstructors();
Ptr<CRoot> pRoot = ORoot();
Ptr<CTestDoubleNamedString> pDouble = pRoot->Get<CTestDoubleNamedString>("Double Start");
Ptr<CTestNamedString> pString1 = pDouble->mpSplit1;
Ptr<CTestNamedString> pString2 = pDouble->mpSplit2;
pString1->ClassName();
pString2->ClassName();
Ptr<CTestNamedString> pDiamond1 = pString1->mpAnother;
Ptr<CTestNamedString> pDiamond2 = pString2->mpAnother;
AssertTrue(pDiamond1.IsHollow());
AssertTrue(pDiamond2.IsHollow());
AssertPointer(pDiamond1.Object(), pDiamond2.Object());
AssertPointer(pString1->mpAnother.Object(), pString2->mpAnother.Object());
AssertLongLongInt(3LL, pDiamond1.GetIndex());
AssertLongLongInt(3LL, pDiamond2.GetIndex());
//Dehollofication of pDiamond1 happens here. pString1->mpAnother and pString2->mpAnother are remapped to the dehollowed diamond object.
pDiamond1->ClassName();
AssertFalse(pDiamond1.IsHollow());
AssertFalse(pDiamond2.IsHollow()); //This should be false but it's not until I remap local pointers.
AssertPointer(pDiamond1.Object(), pDiamond2.Object()); //These should be the same but they're not until I remap local pointers.
AssertLongLongInt(3LL, pDiamond1.GetIndex());
AssertFalse(pString1->mpAnother.IsHollow());
AssertFalse(pString2->mpAnother.IsHollow());
AssertPointer(pString1->mpAnother.Object(), pString2->mpAnother.Object());
ObjectsKill();
MemoryKill();
}
void TestObjectDehollowfication(void)
{
CFileUtil cFileUtil;
CPointer pPointer;
CTestDoubleNamedString* pcInternal;
Ptr<CTestDoubleNamedString> pDouble;
Ptr<CTestNamedString> pSingle;
int iClassSize;
OIndex oiOld;
OIndex oiNew;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Dehollowfication");
ObjectsInit("Output/Dehollowfication");
SetupObjectsForDehollowfication();
gcObjects.Flush(TRUE, TRUE);
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
ObjectsKill();
ObjectsInit("Output/Dehollowfication");
SetupObjectsConstructors();
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
AssertTrue(gcObjects.Contains("Double"));
pPointer = gcObjects.Get("Double");
AssertNotNull(pPointer.Object());
AssertString("CTestDoubleNamedString", pPointer.ClassName());
pcInternal = (CTestDoubleNamedString*)pPointer.Object();
AssertTrue(pcInternal->mpSplit1.IsNotNull());
AssertTrue(pcInternal->mpSplit1.IsHollow());
AssertTrue(pcInternal->mpSplit2.IsNotNull());
AssertTrue(pcInternal->mpSplit2.IsHollow());
pDouble = pPointer;
oiOld = pDouble->mpSplit1.GetIndex();
AssertTrue(pcInternal->mpSplit1.IsHollow()); //Making sure we haven't de-hollowed the object by calling GetIndex.
//Problem - An oi of 1 is briefly assigned to the de-hollowed object and then it is reassigned back to its original value.
iClassSize = pDouble->mpSplit1->ClassSize(); //The method call - ClassSize() - is irrelevant as long as the -> operator on mpSplit1 is invoked.
AssertTrue(pcInternal->mpSplit1.IsNotNull());
AssertFalse(pcInternal->mpSplit1.IsHollow());
AssertInt(sizeof(CTestNamedString), iClassSize);
AssertString("CTestNamedString", pcInternal->mpSplit1.ClassName());
oiNew = pDouble->mpSplit1.GetIndex();
AssertLongLongInt(oiOld, oiNew);
pSingle = pDouble->mpSplit2;
AssertTrue(pcInternal->mpSplit2.IsNotNull());
AssertTrue(pcInternal->mpSplit2.IsHollow());
ObjectsKill();
}
void TestEmbeddedObjectPointTo(void)
{
BOOL bResult;
CFileUtil cFileUtil;
OIndex oiComplex;
char* szClassName;
cFileUtil.RemoveDir("Output/EmbeddedObject");
MemoryInit();
ObjectsInit("Output/EmbeddedObject/");
SetupEmbeddedObjectConstructors();
Ptr<CRoot> pRoot = ORoot();
Ptr<CEmbeddedComplex> pComplex = OMalloc(CEmbeddedComplex)->Init();
oiComplex = pComplex->GetOI();
Ptr<CEmbeddedContainer> pContainer = &pComplex->mcContainer;
pRoot->Add(pContainer);
bResult = gcObjects.Flush(TRUE, TRUE);
AssertTrue(bResult);
ObjectsKill();
MemoryKill();
AssertNull(&pContainer);
MemoryInit();
ObjectsInit("Output/EmbeddedObject/");
SetupEmbeddedObjectConstructors();
pRoot = gcObjects.GetRoot();
AssertTrue(pRoot.IsNotNull());
pContainer = pRoot->Get(0);
AssertTrue(pContainer.IsHollow());
AssertInt(0, pContainer.Object()->GetNumEmbedded());
AssertLongLongInt(-1, pContainer.GetIndex());
szClassName = pContainer->ClassName();
AssertString("CEmbeddedContainer", szClassName);
pComplex = pContainer->GetEmbeddingContainer();
//Kinda feels like this test just stopped...
ObjectsKill();
MemoryKill();
}
void TestDehollowficationFromChunkFileSource(void)
{
CFileUtil cFileUtil;
cFileUtil.RemoveDir("Output\\Dehollowfication\\ChunkFile");
MemoryInit();
ObjectsInit("Output\\Dehollowfication\\Temp");
WriteDehollowficationChunkedFile();
ObjectsKill();
MemoryKill();
cFileUtil.RemoveDir("Output\\Dehollowfication\\Temp");
CObjectSourceChunked* pcObjectSourceChunked;
CDiskFile* pcDiskFile = DiskFile("Output\\Dehollowfication\\ChunkFile\\Double.DRG");
MemoryInit();
ObjectsInit("Output\\Dehollowfication\\Temp");
SetupDehollowficationConstructors();
pcObjectSourceChunked = (CObjectSourceChunked*)gcObjects.AddSource<CObjectConverterNative>(pcDiskFile, "Double"); //Note the .DRG is intentionally dropped.
AssertNotNull(pcObjectSourceChunked);
AssertInt(4, pcObjectSourceChunked->NumNames());
AssertString("Diamond End", pcObjectSourceChunked->GetName(0));
AssertString("Double Start", pcObjectSourceChunked->GetName(1));
AssertString("NamedString 1", pcObjectSourceChunked->GetName(2));
AssertString("NamedString 2", pcObjectSourceChunked->GetName(3));
Ptr<CTestDoubleNamedString> pStart;
pStart = gcObjects.Get("Double Start");
AssertTrue(pStart.IsNotNull());
AssertString("CTestDoubleNamedString", pStart.ClassName());
AssertTrue(pStart->mpSplit1.IsHollow());
AssertTrue(pStart->mpSplit2.IsHollow());
AssertFalse(pStart->mszString.IsHollow());
pStart->mpSplit1->ClassName();
AssertFalse(pStart->mpSplit1.IsHollow());
AssertString("CTestNamedString", pStart->mpSplit1.ClassName());
ObjectsKill();
MemoryKill();
}
void TestObjectsInMemoryIteration()
{
SIndexesIterator sIter;
OIndex oi;
ObjectsInit();
SetupObjectsForDehollowfication();
oi = gcObjects.StartMemoryIteration(&sIter);
AssertLongLongInt(1LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(2LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(3LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(4LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(5LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(6LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(7LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(8LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(9LL, oi);
oi = gcObjects.IterateMemory(&sIter);
AssertLongLongInt(INVALID_O_INDEX, oi);
ObjectsKill();
}
void TestKillLongCyclicSelfPointer(void)
{
ObjectsInit();
Ptr<CRoot> pRoot;
Ptr<CTestNamedObject> pObject1;
Ptr<CTestNamedObject> pObject2;
Ptr<CTestNamedObject> pObjectBase;
BOOL bResult;
pRoot = ORoot();
pObjectBase = OMalloc(CTestNamedObject);
pObject1 = OMalloc(CTestNamedObject);
pObjectBase->Init(0);
pObject1->Init(1);
pObjectBase->mpNamedTest1 = pObject1;
pObject1->mpNamedTest1 = pObjectBase;
pRoot->Add(pObjectBase);
//pObject should be destroyed here and not cause a stack overflow.
bResult = pRoot->Remove(pObjectBase);
AssertTrue(bResult);
ObjectsKill();
}
void TestEmbeddedObjectAddDistToRoot(void)
{
ObjectsInit();
Ptr<CRoot> pRoot = ORoot();
Ptr<CGameWorld> pWorld = OMalloc(CGameWorld)->Init();
pRoot->Add(pWorld);
Ptr<CClusterMissile> pMissile = ONMalloc(CClusterMissile, "Frank")->Init(pWorld);
Ptr<CHarrier> pHarrier = OMalloc(CHarrier)->Init(pWorld);
pWorld->AddPlayer(pHarrier);
AssertInt(3, pHarrier->GetDistToRoot());
pRoot->Add(pMissile);
AssertInt(2, pMissile->GetDistToRoot());
AssertInt(2, pMissile->mcMissile1.GetDistToRoot());
AssertInt(2, pMissile->mcMissile2.GetDistToRoot());
pMissile->mcMissile1.SetTarget(pHarrier);
AssertInt(3, pHarrier->GetDistToRoot());
ObjectsKill();
}
void TestKillSelfPointer1(void)
{
ObjectsInit();
Ptr<CRoot> pRoot;
Ptr<CTestNamedObject> pObject;
BOOL bResult;
CBaseObject* pvObject;
pRoot = ORoot();
pObject = OMalloc(CTestNamedObject);
pObject->Init(1);
pObject->mpNamedTest1 = pObject;
pRoot->Add(pObject);
AssertInt(1, pRoot->NumObjects());
AssertLongLongInt(3, gcObjects.NumMemoryIndexes());
pvObject = pObject.BaseObject();
pObject = NULL;
//pObject should be destroyed here and not cause a stack overflow.
bResult = pRoot->Remove(pvObject);
AssertTrue(bResult);
AssertInt(0, pRoot->NumObjects());
AssertLongLongInt(2, gcObjects.NumMemoryIndexes());
ObjectsKill();
}
void TestKillSelfPointer2(void)
{
ObjectsInit();
Ptr<CRoot> pRoot;
Ptr<CTestNamedObject> pObject;
BOOL bResult;
pRoot = ORoot();
pObject = OMalloc(CTestNamedObject);
pObject->Init(1);
pObject->mpNamedTest1 = pObject;
pRoot->Add(pObject);
AssertInt(1, pRoot->NumObjects());
AssertLongLongInt(3, gcObjects.NumMemoryIndexes());
//pObject should not be destroyed here and not cause a stack overflow.
bResult = pRoot->Remove(pObject);
AssertTrue(bResult);
AssertInt(0, pRoot->NumObjects());
AssertLongLongInt(3, gcObjects.NumMemoryIndexes());
//If there were cyclic pointers then the object cannot tell it should be freed when a stack pointer is removed.
pObject = NULL;
AssertLongLongInt(2, gcObjects.NumMemoryIndexes());
ObjectsKill();
}
void TestEmbeddedGetEmbeddedIndex(void)
{
MemoryInit();
ObjectsInit();
CEmbeddedComplex cComplex;
cComplex.Class();
cComplex.Init();
AssertInt(0, cComplex.TestGetNumEmbeddedFromFlags());
AssertInt(6, cComplex.GetNumEmbedded());
AssertInt(6, cComplex.TestGetNumEmbeddedFromFlags());
AssertInt(1, cComplex.mcSimple.GetNumEmbedded());
AssertInt(1, cComplex.ma.GetNumEmbedded());
AssertInt(3, cComplex.mcContainer.GetNumEmbedded());
AssertInt(1, cComplex.mcContainer.mcOne.GetNumEmbedded());
AssertInt(1, cComplex.mcContainer.mcOne.GetNumEmbedded());
AssertInt(0, cComplex.GetEmbeddedIndex(&cComplex));
AssertInt(1, cComplex.GetEmbeddedIndex(&cComplex.mcSimple));
AssertInt(2, cComplex.GetEmbeddedIndex(&cComplex.ma));
AssertInt(3, cComplex.GetEmbeddedIndex(&cComplex.mcContainer));
AssertInt(4, cComplex.GetEmbeddedIndex(&cComplex.mcContainer.mcOne));
AssertInt(5, cComplex.GetEmbeddedIndex(&cComplex.mcContainer.mcTwo));
AssertInt(-1, cComplex.GetEmbeddedIndex(NULL));
ObjectsKill();
MemoryKill();
}
void TestObjectsFlushRemovesStackPointers(void)
{
CFileUtil cFileUtil;
Ptr<CTestDoubleNamedString> pDouble;
Ptr<CRoot> pRoot;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/ClearPointers");
ObjectsInit("Output/ClearPointers");
SetupObjectsConstructors();
pRoot = ORoot();
gcObjects.Flush(TRUE, TRUE);
AssertLongLongInt(2, gcObjects.NumDatabaseObjects());
AssertNull(&pRoot);
pDouble = ONMalloc(CTestDoubleNamedString, "Double")->Init();
AssertString("CTestDoubleNamedString", pDouble.ClassName());
pRoot = ORoot();
AssertString("CRoot", pRoot.ClassName());
ObjectsKill();
}
void TestObjectsFlushClearGetByName(void)
{
CFileUtil cFileUtil;
CPointer pObject;
Ptr<CTestDoubleNamedString> pDouble;
Ptr<CRoot> pRoot;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Dehollowfication");
ObjectsInit("Output/Dehollowfication");
SetupObjectsConstructors();
pRoot = ORoot();
pDouble = ONMalloc(CTestDoubleNamedString, "Double")->Init();
pRoot->Add(pDouble);
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumDatabaseNames());
pObject = gcObjects.Get(3);
AssertNotNull(pObject.Object());
AssertString("CTestDoubleNamedString", pObject.ClassName());
gcObjects.Flush(TRUE, TRUE);
AssertLongLongInt(3, gcObjects.NumDatabaseObjects());
AssertLongLongInt(2, gcObjects.NumDatabaseNames());
pObject = gcObjects.Get("Double");
AssertNotNull(pObject.Object());
AssertString("CTestDoubleNamedString", pObject.ClassName());
ObjectsKill();
}
void TestUsageNullPointers(void)
{
ObjectsInit();
Ptr<CGameWorld> pWorld;
CPointer pNull = ONull;
Ptr<CPlayerVehicle> pVehicle = ONull;
Ptr<CHarrier> pHarrier;
pWorld = pNull;
pWorld->AddTickable(pNull);
pWorld->AddTickable(pVehicle);
pWorld->AddTickable(ONull);
pVehicle = pNull;
pWorld->AddPlayer(pVehicle);
pWorld->AddPlayer(pNull);
pWorld->AddPlayer(ONull);
pVehicle = pHarrier;
AssertString("This code must compile", "This code must compile");
pWorld = pHarrier; //This probably shouldn't compile but it does because pHarrier (Ptr<CHarrier>) extends CPointer.
ObjectsKill();
}
void TestWinText(void)
{
BeginTests();
ObjectsInit();
CWinText cWinText;
SWinFontInstance* psWinFont;
Ptr<CFont> pcFont;
CGlyph* pcCel;
CImage cDestImage;
cWinText.Init(NULL);
psWinFont = cWinText.Create("Fixedsys", 0, 0, FW_DONTCARE);
pcFont = cWinText.GenerateFont(psWinFont, "Fixedsys");
WriteImage(&pcFont->GetImage(), "Output/Fixedsys.bmp");
AssertFile("Input/Fixedsys.bmp", "Output/Fixedsys.bmp");
pcCel = pcFont->GetGlyph('H');
pcCel->GetSubImage()->SetAlignment(SUB_IMAGE_ALIGNMENT_LEFT|SUB_IMAGE_ALIGNMENT_TOP);
cDestImage.Init(pcCel->GetFullWidth(), pcCel->GetFullHeight(), pcCel->GetSourceImage());
cDestImage.Clear();
CImageCopier::Copy(pcCel->GetCel(), &cDestImage, 0, 0);
WriteImage(&cDestImage, "Output/TheLetterH.png");
cDestImage.Kill();
AssertFile("Input/TheLetterH.png", "Output/TheLetterH.png");
pcFont->Kill();
cWinText.Kill();
ObjectsKill();
TestStatistics();
}
void TestObjectReaderSimpleDeserialised(void)
{
WriteObjectReaderSimpleFile();
CObjectReaderSimpleDisk cReader;
CObjectGraphDeserialiser cGraphDeserialiser;
CPointer cBase;
Ptr<CTestNamedString> cNS1;
Ptr<CTestNamedString> cNS2;
CPointer cTemp;
CObjectAllocator cAllocator;
CDependentReadObjects cDependentReadObjects;
MemoryInit();
ObjectsInit();
gcObjects.AddConstructor<CTestNamedString>();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumMemoryIndexes());
cAllocator.Init(&gcObjects);
cDependentReadObjects.Init();
cReader.Init("Output\\ObjectReaderSimple\\Test\\");
cGraphDeserialiser.Init(&cReader, FALSE, &cAllocator, &cDependentReadObjects, gcObjects.GetMemory());
cBase = cGraphDeserialiser.Read("Waggy");
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(2, gcObjects.NumMemoryIndexes());
cNS1 = gcObjects.Get("Waggy");
AssertTrue(cNS1.IsNotNull());
AssertString("NS1", cNS1->mszEmbedded.Text());
cNS2 = gcObjects.Get("Dog");
AssertTrue(cNS2.IsNotNull());
AssertString("NS2", cNS2->mszEmbedded.Text());
AssertTrue(cBase.IsNotNull());
AssertString("CTestNamedString", cBase->ClassName());
AssertPointer(&cNS1, &cBase);
AssertPointer(&cNS2, &cNS1->mpAnother);
AssertPointer(NULL, &cNS2->mpAnother);
cGraphDeserialiser.Kill();
cDependentReadObjects.Kill();
cAllocator.Kill();
cReader.Kill();
ObjectsKill();
}
void TestEmbeddedFlags(void)
{
ObjectsInit();
CEmbeddedComplex cComplex;
AssertFalse(cComplex.HasClass());
AssertFalse(cComplex.ma.HasClass());
AssertFalse(cComplex.mcSimple.HasClass());
AssertFalse(cComplex.mcContainer.HasClass());
AssertFalse(cComplex.mcContainer.mcOne.HasClass());
AssertFalse(cComplex.mcContainer.mcTwo.HasClass());
AssertFalse(cComplex.IsInitialised());
AssertFalse(cComplex.ma.IsInitialised());
AssertFalse(cComplex.mcSimple.IsInitialised());
AssertFalse(cComplex.mcContainer.IsInitialised());
AssertFalse(cComplex.mcContainer.mcOne.IsInitialised());
AssertFalse(cComplex.mcContainer.mcTwo.IsInitialised());
cComplex.Class();
AssertTrue(cComplex.HasClass());
AssertTrue(cComplex.ma.HasClass());
AssertTrue(cComplex.mcSimple.HasClass());
AssertTrue(cComplex.mcContainer.HasClass());
AssertTrue(cComplex.mcContainer.mcOne.HasClass());
AssertTrue(cComplex.mcContainer.mcTwo.HasClass());
AssertFalse(cComplex.IsInitialised());
AssertFalse(cComplex.ma.IsInitialised());
AssertFalse(cComplex.mcSimple.IsInitialised());
AssertFalse(cComplex.mcContainer.IsInitialised());
AssertFalse(cComplex.mcContainer.mcOne.IsInitialised());
AssertFalse(cComplex.mcContainer.mcTwo.IsInitialised());
cComplex.Init();
AssertTrue(cComplex.HasClass());
AssertTrue(cComplex.ma.HasClass());
AssertTrue(cComplex.mcSimple.HasClass());
AssertTrue(cComplex.mcContainer.HasClass());
AssertTrue(cComplex.mcContainer.mcOne.HasClass());
AssertTrue(cComplex.mcContainer.mcTwo.HasClass());
AssertTrue(cComplex.IsInitialised());
AssertTrue(cComplex.ma.IsInitialised());
AssertTrue(cComplex.mcSimple.IsInitialised());
AssertTrue(cComplex.mcContainer.IsInitialised());
AssertTrue(cComplex.mcContainer.mcOne.IsInitialised());
AssertTrue(cComplex.mcContainer.mcTwo.IsInitialised());
cComplex.Kill();
ObjectsKill();
}
void TestObjectsFlushNoClear(void)
{
CFileUtil cFileUtil;
BOOL bResult;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Flush1");
ObjectsInit("Output/Flush1");
SetupObjectsForDehollowfication();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumDatabaseNames());
AssertLongLongInt(9, gcObjects.NumMemoryIndexes());
AssertLongLongInt(6, gcObjects.NumMemoryNames());
bResult = gcObjects.Flush(FALSE, FALSE);
AssertTrue(bResult);
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
AssertLongLongInt(6, gcObjects.NumDatabaseNames());
AssertLongLongInt(9, gcObjects.NumMemoryIndexes());
AssertLongLongInt(6, gcObjects.NumMemoryNames());
ObjectsKill();
CArrayChars aszFileNames;
int i;
CChars* psz;
CChars szOutput;
CChars szFileName;
aszFileNames.Init();
cFileUtil.FindAllFiles("Input/Dehollowfication", &aszFileNames, FALSE, FALSE);
for (i = 0; i < aszFileNames.NumElements(); i++)
{
psz = aszFileNames.Get(i);
szFileName.Init(psz->Text());
cFileUtil.RemovePath(&szFileName);
szOutput.Init();
cFileUtil.CurrentDirectory(&szOutput);
cFileUtil.AppendToPath(&szOutput, "Output/Flush1");
cFileUtil.AppendToPath(&szOutput, szFileName.Text());
AssertFile(psz->Text(), szOutput.Text());
szOutput.Kill();
szFileName.Kill();
}
aszFileNames.Kill();
}
void TestEmbeddedStackPointersComplex(void)
{
ObjectsInit();
CEmbeddedComplex cComplexOnStack1;
CEmbeddedComplex cComplexOnStack2;
Ptr<CTestObject> pTestObject1;
STestObjectKilledNotifier sKillNotifier1;
Ptr<CTestObject> pTestObject2;
STestObjectKilledNotifier sKillNotifier2;
cComplexOnStack1.Class();
cComplexOnStack2.Class();
cComplexOnStack1.Init();
cComplexOnStack2.Init();
pTestObject1 = OMalloc(CTestObject);
pTestObject1->Init(&sKillNotifier1);
pTestObject2 = OMalloc(CTestObject);
pTestObject2->Init(&sKillNotifier2);
AssertInt(0, cComplexOnStack1.GetDistToStack());
AssertInt(0, cComplexOnStack1.NumStackFroms());
AssertInt(0, cComplexOnStack2.GetDistToStack());
AssertInt(0, cComplexOnStack2.NumStackFroms());
cComplexOnStack1.mpTest = &cComplexOnStack2;
cComplexOnStack1.mcSimple.mpTest = &cComplexOnStack2;
cComplexOnStack1.mcContainer.mcOne.mpTest = pTestObject1;
cComplexOnStack2.mcContainer.mcOne.mpTest = pTestObject1;
AssertInt(0, cComplexOnStack1.GetDistToStack());
AssertInt(0, cComplexOnStack1.NumStackFroms());
AssertInt(3, cComplexOnStack1.NumPointerTos());
AssertInt(0, cComplexOnStack2.GetDistToStack());
AssertInt(2, cComplexOnStack2.NumStackFroms());
AssertInt(1, cComplexOnStack2.NumPointerTos());
AssertFalse(sKillNotifier1.bKilled);
AssertFalse(sKillNotifier2.bKilled);
TestEmbeddedStackPointersComplex(&cComplexOnStack1, &cComplexOnStack2);
AssertFalse(sKillNotifier1.bKilled);
AssertFalse(sKillNotifier2.bKilled);
AssertInt(0, cComplexOnStack1.GetDistToStack());
AssertInt(0, cComplexOnStack1.NumStackFroms());
AssertInt(0, cComplexOnStack2.GetDistToStack());
AssertInt(2, cComplexOnStack2.NumStackFroms());
ObjectsKill();
}
void TestEmbeddedObjectRemoveDistToRoot(void)
{
ObjectsInit();
Ptr<CRoot> pRoot = ORoot();
Ptr<CGameWorld> pWorld = OMalloc(CGameWorld)->Init();
pRoot->Add(pWorld);
Ptr<CClusterMissile> pMissile = ONMalloc(CClusterMissile, "Frank")->Init(pWorld);
Ptr<CHarrier> pHarrier = OMalloc(CHarrier)->Init(pWorld);
Ptr<CMissile> pHolder = OMalloc(CMissile)->Init(pWorld);
pWorld->AddTickable(pHolder);
AssertInt(4, pHolder->GetDistToRoot());
pHolder->SetTarget(pHarrier);
AssertInt(5, pHarrier->GetDistToRoot());
Ptr<CClusterLauncher> pLauncher = OMalloc(CClusterLauncher)->Init();
pRoot->Add(pLauncher);
AssertInt(2, pLauncher->GetDistToRoot());
pLauncher->mpMissile = pMissile;
AssertInt(3, pMissile->GetDistToRoot());
AssertInt(3, pMissile->mcMissile1.GetDistToRoot());
AssertInt(3, pMissile->mcMissile2.GetDistToRoot());
AssertInt(5, pHarrier->GetDistToRoot());
AssertInt(1, pHarrier->NumHeapFroms());
pMissile->mcMissile1.SetTarget(pHarrier);
AssertInt(4, pHarrier->GetDistToRoot());
AssertInt(2, pHarrier->NumHeapFroms());
pWorld->RemoveTickable(pHolder);
pHolder = NULL;
AssertInt(4, pHarrier->GetDistToRoot());
AssertInt(1, pHarrier->NumHeapFroms());
pRoot->Add(pHarrier);
AssertInt(2, pHarrier->GetDistToRoot());
pRoot->Remove(pHarrier);
AssertInt(4, pHarrier->GetDistToRoot());
ObjectsKill();
}
void TestObjectReaderChunked(void)
{
CFileUtil cFileUtil;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/ObjectReaderChunked");
ObjectsInit();
BeginTests();
TestObjectReaderChunkedDeserialised();
TestStatistics();
ObjectsKill();
cFileUtil.RemoveDir("Output");
}
void TestEmbeddedStackPointersEmbeddedDistPassThruPointer(void)
{
ObjectsInit();
CEmbeddedTest* pcTest;
CEmbeddedComplex cComplex;
Ptr<CEmbeddedTest> pTest;
cComplex.Class();
cComplex.Init();
cComplex.mai[0] = 1234;
cComplex.mai[1] = 7890;
AssertInt(0, cComplex.GetDistToStack());
AssertInt(0, cComplex.NumStackFroms());
Ptr<CEmbeddedComplex> pComplex;
pComplex = &cComplex;
AssertInt(1, cComplex.NumStackFroms());
AssertInt(1234, pComplex->mai[0]);
AssertInt(7890, pComplex->mai[1]);
AssertInt(0, cComplex.GetDistToStack());
pTest = OMalloc(CEmbeddedTest);
pcTest = (CEmbeddedTest*)pTest.Object();
pTest->Init();
cComplex.mpTest = pTest;
AssertInt(UNKNOWN_DIST_TO_STACK, pcTest->GetDistToStack());
AssertInt(2, pComplex->mpTest->NumStackFroms());
AssertInt(1, cComplex.NumStackFroms());
pTest = NULL;
AssertInt(UNKNOWN_DIST_TO_STACK, pcTest->GetDistToStack());
AssertLongLongInt(1, gcObjects.NumMemoryIndexes());
AssertInt(1, pComplex->mpTest->NumStackFroms());
AssertInt(1, cComplex.NumStackFroms());
cComplex.Kill();
AssertLongLongInt(0, gcObjects.NumMemoryIndexes());
ObjectsKill();
}
void TestEmbeddedObjectClass(void)
{
MemoryInit();
ObjectsInit();
CEmbeddedComplex cComplex;
CPointer* pcPtr0;
CPointer* pcPtr1;
CPointer* pcPtr2;
CPointer* pcPtr3;
CPointer* pcPtr4;
CPointer* pcPtr5;
//Class not yet called. Always call Class.
AssertInt(0, cComplex.GetNumFieldPointerTos());
AssertInt(1, cComplex.GetNumEmbedded());
cComplex.ClearFlagNumEmbedded();
cComplex.Class();
AssertInt(5, cComplex.GetNumFieldPointerTos());
AssertInt(6, cComplex.GetNumEmbedded());
pcPtr0 = cComplex.GetFieldPointerTo(0);
pcPtr1 = cComplex.GetFieldPointerTo(1);
pcPtr2 = cComplex.GetFieldPointerTo(2);
pcPtr3 = cComplex.GetFieldPointerTo(3);
pcPtr4 = cComplex.GetFieldPointerTo(4);
pcPtr5 = cComplex.GetFieldPointerTo(5);
AssertPointer(cComplex.mpTest.This(), pcPtr0);
AssertPointer(cComplex.mcSimple.mpTest.This(), pcPtr1);
AssertPointer(cComplex.mcContainer.mpTest.This(), pcPtr2);
AssertPointer(cComplex.mcContainer.mcOne.mpTest.This(), pcPtr3);
AssertPointer(cComplex.mcContainer.mcTwo.mpTest.This(), pcPtr4);
AssertNull(pcPtr5);
AssertInt(0, cComplex.GetFieldPointerToIndex(pcPtr0));
AssertInt(1, cComplex.GetFieldPointerToIndex(pcPtr1));
AssertInt(2, cComplex.GetFieldPointerToIndex(pcPtr2));
AssertInt(3, cComplex.GetFieldPointerToIndex(pcPtr3));
AssertInt(4, cComplex.GetFieldPointerToIndex(pcPtr4));
AssertInt(-1, cComplex.GetFieldPointerToIndex(NULL));
ObjectsKill();
MemoryKill();
}
void TestObjectsFlushDurable(void)
{
CFileUtil cFileUtil;
BOOL bResult;
CIndexedConfig cConfig;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Flush2");
cConfig.OptimiseForStreaming("Output/Flush2");
cConfig.SetObjectCacheSize(128 MB);
//cConfig.SetWriteThrough(FALSE);
ObjectsInit(&cConfig);
SetupObjectsForDehollowfication();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumDatabaseNames());
AssertLongLongInt(9, gcObjects.NumMemoryIndexes());
AssertLongLongInt(6, gcObjects.NumMemoryNames());
bResult = gcObjects.Flush(FALSE, FALSE);
AssertTrue(bResult);
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
AssertLongLongInt(6, gcObjects.NumDatabaseNames());
AssertLongLongInt(9, gcObjects.NumMemoryIndexes());
AssertLongLongInt(6, gcObjects.NumMemoryNames());
ObjectsKill();
AssertFile("Input/Dehollowfication/48_0.DAT", "Output/Flush2/48_0.DAT");
AssertFile("Input/Dehollowfication/56_0.DAT", "Output/Flush2/56_0.DAT");
AssertFile("Input/Dehollowfication/68_0.DAT", "Output/Flush2/68_0.DAT");
AssertFile("Input/Dehollowfication/89_0.DAT", "Output/Flush2/89_0.DAT");
AssertFile("Input/Dehollowfication/93_0.DAT", "Output/Flush2/93_0.DAT");
AssertFile("Input/Dehollowfication/101_0.DAT", "Output/Flush2/101_0.DAT");
AssertFile("Input/Dehollowfication/102_0.DAT", "Output/Flush2/102_0.DAT");
AssertFile("Input/Dehollowfication/Files.DAT", "Output/Flush2/Files.DAT");
AssertFile("Input/Dehollowfication/Indicies.DAT", "Output/Flush2/Indicies.DAT");
AssertFile("Input/Dehollowfication/32_0.NAM", "Output/Flush2/32_0.NAM");
AssertFile("Input/Dehollowfication/Files.NAM", "Output/Flush2/Files.NAM");
}
void TestObjectsObjectKillInGraph(void)
{
Ptr<CTestNamedString> cNS1;
Ptr<CTestNamedString> cNS2;
Ptr<CRoot> pRoot;
Ptr<CString> cS1;
Ptr<CString> cS2;
CTestNamedString* pcNS2;
CString* pcS2;
ObjectsInit();
pRoot = ORoot();
cS1 = OMalloc(CString);
cS1->Init("CS1");
cNS1 = ONMalloc(CTestNamedString, "NS1")->Init(cS1, ONull, "NS1");
cS2 = OMalloc(CString)->Init("CS2");
cNS2 = ONMalloc(CTestNamedString, "NS2")->Init(cS2, cNS1, "NS2");
pRoot->Add(cNS2);
AssertPointer(cNS2->mpAnother.Object(), cNS1.Object());
AssertLongLongInt(6, gcObjects.NumMemoryIndexes());
pcNS2 = &cNS2;
cNS2 = NULL;
pRoot = NULL;
cS1 = NULL;
pcS2 = &cS2;
cS2 = NULL;
AssertLongLongInt(6, gcObjects.NumMemoryIndexes());
cNS1->Kill();
AssertNull(pcNS2->mpAnother.Object());
AssertLongLongInt(4, gcObjects.NumMemoryIndexes());
AssertPointer(pcNS2->mszString.Object(), pcS2);
ObjectsKill();
}
void WriteObjectReaderSimpleFile(void)
{
MemoryInit();
ObjectsInit();
gcObjects.AddConstructor<CTestNamedString>();
CPointer cBase;
CObjectWriterSimple cWriter;
CObjectGraphSerialiser cGraphSerialiser;
cBase = SetupObjectReaderSimpleFile();
cWriter.Init("Output\\ObjectReaderSimple\\Test\\", "");
cGraphSerialiser.Init(&cWriter);
AssertTrue(cGraphSerialiser.Write(cBase.BaseObject()));
cGraphSerialiser.Kill();
cWriter.Kill();
ObjectsKill();
MemoryKill();
}
void TestEmbeddedStackPointersDestructor(void)
{
ObjectsInit();
CTestObject cTest1;
STestObjectKilledNotifier sKillNotifier1;
STestObjectKilledNotifier sKillNotifier2;
cTest1.Class();
cTest1.Init(&sKillNotifier1);
sKillNotifier2.bKilled = FALSE;
TestEmbeddedStackPointersDestructor(&sKillNotifier2, &cTest1);
AssertTrue(sKillNotifier2.bKilled);
AssertFalse(sKillNotifier1.bKilled);
cTest1.Kill();
ObjectsKill();
}
void TestObjectStackInit(void)
{
ObjectsInit();
CTestObject cObject;
STestObjectKilledNotifier sKillNotifier;
AssertFalse(cObject.IsAllocatedInObjects());
AssertTrue(cObject.GetFlags() & OBJECT_FLAGS_CALLED_CONSTRUCTOR);
AssertFalse(cObject.GetFlags() & OBJECT_FLAGS_CALLED_ALLOCATE);
AssertFalse(cObject.GetFlags() & OBJECT_FLAGS_CALLED_INIT);
AssertInt(0, cObject.GetDistToStack());
AssertInt(UNATTACHED_DIST_TO_ROOT, cObject.GetDistToRoot());
cObject.Class();
cObject.Init(&sKillNotifier);
AssertTrue(cObject.GetFlags() & OBJECT_FLAGS_CALLED_INIT);
ObjectsKill();
}
void TestEmbeddedOjectIsAllocatedInObjects()
{
MemoryInit();
ObjectsInit();
Ptr<CClusterMissile> pClusterMissile = ONMalloc(CClusterMissile, "Gerbil")->Init(NULL);
AssertTrue(pClusterMissile->IsAllocatedInObjects());
AssertTrue(pClusterMissile->mcMissile1.IsAllocatedInObjects());
AssertTrue(pClusterMissile->mcMissile2.IsAllocatedInObjects());
pClusterMissile = NULL;
CClusterMissile cClusterMissile;
cClusterMissile.Class();
cClusterMissile.Init(NULL);
AssertFalse(cClusterMissile.IsAllocatedInObjects());
AssertFalse(cClusterMissile.mcMissile1.IsAllocatedInObjects());
AssertFalse(cClusterMissile.mcMissile2.IsAllocatedInObjects());
ObjectsKill();
MemoryKill();
}
void TestObjectsObjectKillInArrayInGraph(void)
{
Ptr<CTestNamedString> cNS1;
Ptr<CArrayObject> cA1;
Ptr<CArrayObject> cA2;
Ptr<CRoot> pRoot;
Ptr<CString> cS1;
ObjectsInit();
pRoot = ORoot();
cS1 = OMalloc(CString)->Init("CS1");
cNS1 = ONMalloc(CTestNamedString, "NS1")->Init(cS1, ONull, "NS1");
cA1 = OMalloc(CArrayObject)->Init();
cA2 = OMalloc(CArrayObject)->Init();
cA1->Add(cNS1);
cA2->Add(cNS1);
pRoot->Add(cA1);
pRoot->Add(cA2);
AssertInt(1, cA1->NumPointerTos());
AssertInt(1, cA2->NumPointerTos());
AssertLongLongInt(6, gcObjects.NumMemoryIndexes());
pRoot = NULL;
cS1 = NULL;
AssertLongLongInt(6, gcObjects.NumMemoryIndexes());
cNS1->Kill();
AssertLongLongInt(4, gcObjects.NumMemoryIndexes());
AssertInt(0, cA1->NumPointerTos());
AssertInt(0, cA2->NumPointerTos());
ObjectsKill();
}
void TestEmbeddedGetEmbeddedObject(void)
{
MemoryInit();
ObjectsInit();
CEmbeddedComplex cComplex;
CEmbeddedObject* pcEmbedded;
cComplex.Class();
cComplex.Init();
pcEmbedded = cComplex.GetEmbeddedObject(0);
AssertPointer(&cComplex, pcEmbedded);
pcEmbedded = cComplex.GetEmbeddedObject(1);
AssertPointer(&cComplex.mcSimple, pcEmbedded);
pcEmbedded = cComplex.GetEmbeddedObject(2);
AssertPointer(&cComplex.ma, pcEmbedded);
pcEmbedded = cComplex.GetEmbeddedObject(3);
AssertPointer(&cComplex.mcContainer, pcEmbedded);
pcEmbedded = cComplex.GetEmbeddedObject(4);
AssertPointer(&cComplex.mcContainer.mcOne, pcEmbedded);
pcEmbedded = cComplex.GetEmbeddedObject(5);
AssertPointer(&cComplex.mcContainer.mcTwo, pcEmbedded);
pcEmbedded = cComplex.GetEmbeddedObject(6);
AssertNull(pcEmbedded);
pcEmbedded = cComplex.mcSimple.GetEmbeddedObject(0);
AssertPointer(&cComplex.mcSimple, pcEmbedded);
pcEmbedded = cComplex.mcSimple.GetEmbeddedObject(1);
AssertNull(pcEmbedded);
pcEmbedded = cComplex.ma.GetEmbeddedObject(0);
AssertPointer(&cComplex.ma, pcEmbedded);
pcEmbedded = cComplex.ma.GetEmbeddedObject(1);
AssertNull(pcEmbedded);
ObjectsKill();
MemoryKill();
}
