pmtcreationandcleanup.c

Go to the documentation of this file.

class OwnershipTestDummyClass
{
 // Simply exists
}
 
class PMTCreationAndCleanup : PMTF
{
 int m_EventTestManagerID;
 bool m_bTestEventsPassed = false;
 
 int m_OwnershipTestManagerID;
 
 //---------------------------------------------------------------------------
 // Ctor - Decides the tests to run
 //---------------------------------------------------------------------------
 void PMTCreationAndCleanup()
 {
 //AddInitTest("TestInvalidSize");
 AddInitTest("TestCCSB");
 AddInitTest("TestEvents");
 AddInitTest("TestOwnership");
 }
 
 //---------------------------------------------------------------------------
 // Tests
 //---------------------------------------------------------------------------
 // Test invalid size VMEs
 TFResult TestInvalidSize()
 {
 Debug.ParticleLog("Expecting VME: Invalid size. (0)", this, "TestInvalidSize");
 TestCreationSmallBlocking(0, false);
 
 Debug.ParticleLog("Expecting VME: Invalid size. (-3)", this, "TestInvalidSize");
 TestCreationSmallBlocking(-3, false);
 
 return NTFR(TFR.SUCCESS); // No way to check if a VME popped or not...
 }
 
 //---------------------------------------------------------------------------
 // TestCreationCleanupSmallBlocking
 TFResult TestCCSB()
 {
 return TestCleanup("TestMultiCreation", 3000);
 }
 
 //---------------------------------------------------------------------------
 // Test if events are called properly
 TFResult TestEvents()
 {
 ParticleManager pm = new ParticleManager(new ParticleManagerSettings(3000));
 bool success = !pm.IsFinishedAllocating(); // We need it to not be done in the same frame
 if (Assert(success))
 {
 pm.GetEvents().Event_OnAllocationEnd.Insert(PassCheckEvents);
 
 m_EventTestManagerID = InsertManager(pm);
 AddFrameTest("CheckTestEvents");
 
 return NTFR(TFR.SUCCESS);
 }
 
 return NTFR(TFR.FAIL);
 }
 
 //---------------------------------------------------------------------------
 // Test ownership
 TFResult TestOwnership()
 {
 ParticleManager pm = CreatePMFixedBlocking(1);
 bool success = pm.IsFinishedAllocating(); // We need it to be done in the same frame
 if (Assert(success))
 { 
 m_OwnershipTestManagerID = InsertManager(pm);
 OwnershipTestDummyClass dummy = new OwnershipTestDummyClass();
 
 ParticleProperties pp = new ParticleProperties(GetGame().GetPlayer().GetPosition(), ParticlePropertiesFlags.NONE, null, vector.Zero, dummy);
 string particlePath = ParticleList.GetParticleFullPath(ParticleList.EXPLOSION_LANDMINE);
 
 bool result = Assert(pm.CreateParticleByPath(particlePath, pp) != null);
 Debug.ParticleLog("Expecting VME: All particles in pool are already used.", this, "TestOwnership");
 result &= Assert(pm.CreateParticleByPath(particlePath, pp) == null);
 delete dummy;
 result &= Assert(pm.CreateParticleByPath(particlePath, pp) != null); 
 
 return BTFR(result);
 }
 
 return NTFR(TFR.FAIL);
 }
 
 //---------------------------------------------------------------------------
 // OnFrame Checks
 //---------------------------------------------------------------------------
 TFResult CheckTestEvents()
 {
 ParticleManager pm;
 if (GetManager(m_EventTestManagerID, pm))
 {
 if (pm)
 {
 if (pm.IsFinishedAllocating())
 {
 return BTFR(Assert(m_bTestEventsPassed));
 }
 }
 else
 {
 return BTFR(Assert(false));
 }
 }
 else
 {
 return BTFR(Assert(false));
 }
 
 return NTFR(TFR.PENDING);
 }
 
 //---------------------------------------------------------------------------
 // Passes
 //---------------------------------------------------------------------------
 void PassCheckEvents(ParticleManager pm)
 {
 Assert(pm.IsFinishedAllocating());
 m_bTestEventsPassed = true;
 }
 
 //---------------------------------------------------------------------------
 // Helpers
 //---------------------------------------------------------------------------
 TFResult TestCreationSmallBlocking(int size, bool enableAsserts = true)
 {
 // Blocking, so that we can test AllocatedCount
 ParticleManager pm = CreatePMFixedBlocking(size);
 PrintPMStats(pm);
 
 bool success = true;
 
 if (enableAsserts)
 {
 success &= Assert(pm.GetPoolSize() == size);
 success &= Assert(pm.GetAllocatedCount() == size);
 success &= Assert(pm.GetEvents() != null);
 }
 
 return BTFR(success);
 }
 
 TFResult TestCleanup(string f, int p1 = 0)
 { 
 int pmTotal = ParticleManager.GetStaticActiveCount();
 int psTotal = ParticleSource.GetStaticActiveCount();
 
 PrintActiveStats();
 
 TFResult res = CTFR();
 
 GetGame().GameScript.CallFunction(this, f, res, p1);
 
 int pmTotalPost = ParticleManager.GetStaticActiveCount();
 int psTotalPost = ParticleSource.GetStaticActiveCount();
 
 PrintActiveStats();
 
 bool success = Assert(pmTotal == pmTotalPost);
 success &= Assert(psTotal == psTotalPost);
 
 return res.And(BTFR(success));
 }
 
 TFResult TestMultiCreation(int instances)
 {
 TFResult res = CTFR();
 for (int i = 0; i < instances; ++i)
 {
 res.And(TestCreationSmallBlocking(1));
 }
 return res;
 }
}