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;
  }
}