SCR_AutotestPrinter.c

Go to the documentation of this file.

class SCR_AutotestPrinter
{
    static const string LOG_PATH = "$logs:autotest.log";
    static const int LOG_ONCE_THRESHOLD = 10000;
 
    protected bool m_bLogVerbose;
    protected ref FileHandle m_LogFile;
 
    protected ref map<typename, ref array<string>> m_mLogBuffer = new map<typename, ref array<string>>();
 
    protected string m_sLogOnceLastMsg;
    protected int m_iLogOnceLastMsgCount;
 
    //------------------------------------------------------------------------------------------------
    void PrintTestSuitePrelude(TestSuite suite)
    {
        Log("");
        Log("############################################/");
        Log(string.Format("TestSuite #%1 started", suite.ClassName()));
    }
 
    //------------------------------------------------------------------------------------------------
    void PrintTestSuiteEpilogue(TestSuite suite)
    {
        Log("/############################################");
        Log("");
    }
 
    //------------------------------------------------------------------------------------------------
    void Log(string msg, LogLevel level = LogLevel.NORMAL, bool forceFileWrite = false, bool consoleLog = true)
    {
        // dump info how many "LogOnce"s preceeded this message
        if (m_iLogOnceLastMsgCount > 0)
        {
            string logOnceMsg = string.Format("(x%2) %1", m_sLogOnceLastMsg, m_iLogOnceLastMsgCount);
            m_iLogOnceLastMsgCount = 0;
            m_sLogOnceLastMsg = "";
            Log(logOnceMsg);
        }
 
        if (consoleLog)
        {
            Print("" + msg, level);
        }
 
        string msgFile = string.Format("%3 %1%2", GetLogPrefix(level), msg, GetTimeLocal());
 
        TestBase activeTest = SCR_AutotestHarness.ActiveTestCase();
        if (activeTest && !forceFileWrite)
        {
            typename activeTestType = activeTest.Type();
            if (!m_mLogBuffer.Contains(activeTestType))
            {
                m_mLogBuffer.Insert(activeTestType, {});
            }
 
            array<string> buffer = m_mLogBuffer.Get(activeTestType);
            buffer.Insert(msgFile);
        }
        else
        {
            m_LogFile.WriteLine(msgFile);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void LogOnce(string msg, LogLevel level = LogLevel.NORMAL)
    {
        if (msg == m_sLogOnceLastMsg && m_iLogOnceLastMsgCount < LOG_ONCE_THRESHOLD)
        {
            m_iLogOnceLastMsgCount++;
            return;
        }
 
        if (msg == m_sLogOnceLastMsg && m_iLogOnceLastMsgCount >= LOG_ONCE_THRESHOLD)
        {
            int count = m_iLogOnceLastMsgCount;
            m_iLogOnceLastMsgCount = 0;
            Log(string.Format("(x%2) %1", m_sLogOnceLastMsg, count), level);
 
            return;
        }
 
        m_sLogOnceLastMsg = msg;
        m_iLogOnceLastMsgCount = 0;
        Log(msg, level);
    }
 
    //------------------------------------------------------------------------------------------------
    void LogTestCaseResult(TestBase test)
    {
        TestResultBase result = test.GetResult();
        if (!result)
        {
            Log(string.Format("\t⚠️ %1: NO_RESULT", test.GetName()), forceFileWrite: true);
            return;
        }
 
        if (TestResultTimeout.Cast(result))
        {
            Log(string.Format("\t⌚ %1: FAILURE", test.GetName()), forceFileWrite: true);
            Log(string.Format("\t\tFailure reason: %1", "timeout"), forceFileWrite: true);
            DumpTestBuffer(test.Type());
            return;
        }
 
        if (result.Failure())
        {
            Log(string.Format("\t⛔ %1: FAILURE", test.GetName()), forceFileWrite: true);
            
            string failureReason = result.FailureText();
            SCR_AutotestResult autotestResult = SCR_AutotestResult.Cast(result);
            if (autotestResult)
                failureReason = autotestResult.GetFailureReason();
 
            Log(string.Format("\t\tFailure reason: %1", failureReason), forceFileWrite: true);
            
            DumpTestBuffer(test.Type());
        }
        else
        {
            Log(string.Format("\t✅ %1: SUCCESS", test.GetName()), forceFileWrite: true);
            if (m_bLogVerbose)
            {
                DumpTestBuffer(test.Type());
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    private void DumpTestBuffer(typename testType)
    {
        array<string> buffer = m_mLogBuffer.Get(testType);
        if (!buffer)
        {
            Log("\t Output: <none>", forceFileWrite: true, consoleLog: false);
            return;
        }
 
        Log("\t Output:", forceFileWrite: true, consoleLog: false);
        foreach (string msgFile : buffer)
        {
            m_LogFile.WriteLine("\t" + msgFile);
        }
 
        m_mLogBuffer.Remove(testType);
    }
 
    //------------------------------------------------------------------------------------------------
    private string GetLogPrefix(LogLevel level)
    {
        if (level <= LogLevel.NORMAL)
            return "";
 
        return string.Format("(%1): ", typename.EnumToString(LogLevel, level));
    }
    
    //------------------------------------------------------------------------------------------------
    private string GetTimeLocal()
    {
        int hour, minute, second;
        System.GetHourMinuteSecond(hour, minute, second);
        
        return string.Format("%1:%2:%3", hour.ToString(2), minute.ToString(2), second.ToString(2));
    }
 
    //------------------------------------------------------------------------------------------------
    void SCR_AutotestPrinter(bool verbose)
    {
        m_bLogVerbose = verbose;
        m_LogFile = FileIO.OpenFile(LOG_PATH, FileMode.WRITE);
    }
 
    //------------------------------------------------------------------------------------------------
    void ~SCR_AutotestPrinter()
    {
        m_LogFile.Close();
    }
}