testframework.c

Go to the documentation of this file.

enum TFR
{
 FAIL = -1,
 SUCCESS,
 PENDING,
}
 
class TFResult // Pretty much just to be able to keep a reference...
{
 TFR Result;
 
 void TFResult(TFR result)
 {
 Result = result;
 }
 
 TFResult And(TFResult other)
 {
 if (Result == TFR.PENDING || other.Result == TFR.PENDING)
 ErrorEx("Trying to And while one of the results are PENDING.");
 
 if (Result == TFR.SUCCESS && other.Result == TFR.SUCCESS)
 Result = TFR.SUCCESS;
 else
 Result = TFR.FAIL;
 
 return this;
 }
 
 TFResult Or(TFResult other)
 {
 if (Result == TFR.PENDING || other.Result == TFR.PENDING)
 ErrorEx("Trying to Or while one of the results are PENDING.");
 
 if (Result == TFR.SUCCESS || other.Result == TFR.SUCCESS)
 Result = TFR.SUCCESS;
 else
 Result = TFR.FAIL;
 
 return this;
 }
}
typedef array<ref TFResult> TFResultArr;
 
class TFCaller
{
 private Class m_Instance;
 private string m_Test;
 private ref TFResult m_Result;
 
 void TFCaller(Class instance, string test, TFResult result)
 {
 m_Instance = instance;
 m_Test = test;
 m_Result = result;
 }
 
 TFResult Run(float dt)
 {
 bool callResult = GetGame().GameScript.CallFunction(m_Instance, m_Test, m_Result, dt);
 if (!callResult)
 {
 ErrorEx(string.Format("Failed to call function \'%1\' on \'%2\'", m_Test, m_Instance.GetDebugName()));
 m_Result.Result = TFR.FAIL;
 }
 
 return m_Result;
 }
 
 string GetTest()
 {
 return m_Test;
 }
 
 string GetTestEx()
 {
 return string.Format("%1::%2", m_Instance.ClassName(), m_Test);
 }
}
typedef array<ref TFCaller> TFCallerArr;
 
class TFModule
{
 private int m_Count;
 private int m_Failed;
 private int m_Success;
 
 private ref TFCallerArr m_Tests;
 private ref TFResultArr m_Results;
 
 private ref array<string> m_SucceededTests;
 private ref array<string> m_FailedTests;
 
 void TFModule()
 {
 m_Tests = {};
 m_Results = {};
 
 m_SucceededTests = {};
 m_FailedTests = {};
 }
 
 int Count()
 {
 return m_Count;
 }
 
 int Failed()
 {
 return m_Failed;
 }
 
 int Success()
 {
 return m_Success;
 }
 
 int Pending()
 {
 return m_Count - (m_Failed + m_Success);
 }
 
 void AddTest(Class instance, string test, bool repeat)
 {
 ++m_Count;
 
 TFResult result = new TFResult(TFR.PENDING);
 m_Results.Insert(result);
 
 m_Tests.Insert(new TFCaller(instance, test, result));
 }
 
 bool Run(bool fatal, float dt)
 {
 array<TFCaller> done = new array<TFCaller>();
 
 // Run the tests
 int runningTests = m_Tests.Count();
 for (int i = 0; i < runningTests; ++i)
 {
 TFCaller t = m_Tests[i];
 if (RunTest(t, dt))
 done.Insert(t);
 }
 
 // Remove finished tests
 foreach (TFCaller doneT : done)
 m_Tests.RemoveItem(doneT);
 
 // Validate fatal
 if (fatal && m_Tests.Count() > 0)
 {
 Print("- Active tests -------------------------");
 foreach (TFCaller rTest : m_Tests)
 Print(rTest.GetTest());
 Print("----------------------------------------");
 
 ErrorEx("Not all tests are done while run was fatal.");
 m_Tests.Clear();
 }
 
 return m_Tests.Count() == 0;
 }
 
 private bool RunTest(TFCaller caller, float dt)
 {
 TFR res = caller.Run(dt).Result;
 
 switch (res)
 {
 case TFR.FAIL:
 ++m_Failed;
 m_FailedTests.Insert(caller.GetTestEx());
 break;
 case TFR.SUCCESS:
 ++m_Success;
 m_SucceededTests.Insert(caller.GetTestEx());
 break;
 }
 
 return res != TFR.PENDING;
 }
 
 string Result()
 {
 return string.Format("{ [TFModule] :: Tests: %1 | Success: %2 | Failed: %3 | Pending: %4 }", Count(), Success(), Failed(), Pending());
 }
 
 void PrintResult(string prefix = "", TestFramework caller = null, string function = "")
 {
 Debug.TFLog(string.Format("%1%2", prefix, Result()), caller, function);
 if (m_SucceededTests.Count())
 {
 Debug.TFLog(" |-[SUCCESS]", caller, function);
 foreach (string success : m_SucceededTests)
 {
 Debug.TFLog(string.Format(" |- %1", success), caller, function);
 }
 }
 if (m_FailedTests.Count())
 {
 Debug.TFLog(" |-[FAILED]", caller, function);
 foreach (string fail : m_FailedTests)
 {
 Debug.TFLog(string.Format(" |- %1", fail), caller, function);
 }
 }
 }
}
 
class TestFramework : ScriptedEntity
{
 private ref TFModule m_OnInitModule;
 private ref TFModule m_OnFrameModule;
 
 void TestFramework()
 {
 SetEventMask(EntityEvent.INIT);
 SetEventMask(EntityEvent.FRAME);
 
 m_OnInitModule = new TFModule();
 m_OnFrameModule = new TFModule();
 }
 
 void ~TestFramework()
 {
 m_OnInitModule.PrintResult("IM: ", this, "~TestFrameWork");
 m_OnFrameModule.PrintResult("FM: ", this, "~TestFrameWork");
 }
 
 //---------------------------------------------------------------------------
 // Perform tests
 //---------------------------------------------------------------------------
 protected override void EOnInit(IEntity other, int extra)
 {
 m_OnInitModule.Run(true, 0);
 }
 
 protected override void EOnFrame(IEntity other, float timeSlice)
 {
 if (m_OnFrameModule.Run(false, timeSlice))
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(Delete);
 }
 
 //---------------------------------------------------------------------------
 // Add a test
 //---------------------------------------------------------------------------
 protected void AddInitTest(string test)
 {
 m_OnInitModule.AddTest(this, test, false);
 }
 
 protected void AddFrameTest(string test)
 {
 m_OnFrameModule.AddTest(this, test, true);
 }
 
 //---------------------------------------------------------------------------
 // Asserts
 //---------------------------------------------------------------------------
 protected bool Assert(bool condition)
 {
 if (!condition)
 ErrorEx("ASSERTION FAILED.");
 
 return condition;
 }
 
 //---------------------------------------------------------------------------
 // Helpers
 //---------------------------------------------------------------------------
 TFResult NTFR(TFR result)
 {
 return new TFResult(result);
 }
 
 TFResult BTFR(bool result)
 {
 if (result)
 return new TFResult(TFR.SUCCESS);
 else
 return new TFResult(TFR.FAIL);
 }
 
 TFResult CTFR()
 {
 return new TFResult(TFR.SUCCESS);
 }
}