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