Sleep()

float Sleep2::Sleep

(

float

timeS

)

См. определение в файле EnProfilerTests.c строка 1468

                      : TestFramework
{
    bool m_bWasProfilerEnabled;
    
    //---------------------------------------------------------------------------
    // Ctor - Decides the tests to run
    //---------------------------------------------------------------------------
    void EnProfilerTests()
    {
        m_bWasProfilerEnabled = EnProfiler.IsEnabledC();
        
        AddInitTest("TestToggling");
        AddInitTest("TestTogglingImmediate");
        AddInitTest("TestSetFlags");
        AddInitTest("TestClearFlags");
        AddInitTest("TestAddFlags");
        AddInitTest("TestModule");
        AddInitTest("TestClassTimeData");
        AddInitTest("TestClassCountData");
        AddInitTest("TestFuncTimeData");
        AddInitTest("TestFuncCountData");        
    }
    
    //---------------------------------------------------------------------------
    // Dtor
    //---------------------------------------------------------------------------
    void ~EnProfilerTests()
    {
        EnProfiler.Enable(m_bWasProfilerEnabled, true);
    }
    
    //---------------------------------------------------------------------------
    // Tests
    //---------------------------------------------------------------------------
    // Test toggling state
    TFResult TestToggling()
    {
        bool currentlyEnabled = EnProfiler.IsEnabledP();
        EnProfiler.Enable(!currentlyEnabled);
        if (Assert(currentlyEnabled != EnProfiler.IsEnabledP()))
        {
            EnProfiler.Enable(currentlyEnabled);                
            return BTFR(Assert(currentlyEnabled == EnProfiler.IsEnabledP()));
        }
        
        return NTFR(TFR.FAIL);
    }
    
    //---------------------------------------------------------------------------
    // Test toggling immediate state
    TFResult TestTogglingImmediate()
    {
        bool currentlyEnabled = EnProfiler.IsEnabledC();
        EnProfiler.Enable(!currentlyEnabled, true);
        if (Assert(currentlyEnabled != EnProfiler.IsEnabledC()))
        {
            EnProfiler.Enable(currentlyEnabled, true);              
            return BTFR(Assert(currentlyEnabled == EnProfiler.IsEnabledC()));
        }
        
        return NTFR(TFR.FAIL);
    }
    
    //---------------------------------------------------------------------------
    // Test SetFlags/GetFlags
    TFResult TestSetFlags()
    {
        int currentFlags = EnProfiler.GetFlags();
        
        for (int i = 0; i < EnumTools.GetEnumSize(EnProfilerFlags); ++i)
        {
            int flags = EnumTools.GetEnumValue(EnProfilerFlags, i);
            EnProfiler.SetFlags(flags);
            
            if (!Assert(EnProfiler.GetFlags() == flags))
            {
                EnProfiler.SetFlags(currentFlags);
                return NTFR(TFR.FAIL);
            }
            
            for (int j = 0; j < EnumTools.GetEnumSize(EnProfilerFlags); ++j)
            {
                flags |= EnumTools.GetEnumValue(EnProfilerFlags, j);
                EnProfiler.SetFlags(flags);
                
                if (!Assert(EnProfiler.GetFlags() == flags))
                {
                    EnProfiler.SetFlags(currentFlags);
                    return NTFR(TFR.FAIL);
                }
            }
        }
        
        // Let's test some bogus
        EnProfiler.SetFlags(-333);
        int bogusFlags = EnProfiler.GetFlags();
        bogusFlags &= ~EnProfilerFlags.ALL;
        if (!Assert(bogusFlags == 0))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        bogusFlags = EnProfiler.SetFlags(6003);
        bogusFlags &= ~EnProfilerFlags.ALL;
        if (!Assert(bogusFlags == 0))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        // Reset
        EnProfiler.SetFlags(currentFlags);        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Test removing of flags
    TFResult TestClearFlags()
    {
        int currentFlags = EnProfiler.GetFlags();
                        
        EnProfiler.SetFlags(EnProfilerFlags.RECURSIVE);
        
        if (!Assert(EnProfiler.RemoveFlags(EnProfilerFlags.RECURSIVE) == EnProfilerFlags.NONE))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        EnProfiler.SetFlags(EnProfilerFlags.RECURSIVE | EnProfilerFlags.RESET);
        EnProfiler.RemoveFlags(EnProfilerFlags.RECURSIVE | EnProfilerFlags.RESET);
        
        if (!Assert(EnProfiler.GetFlags() == EnProfilerFlags.NONE))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        EnProfiler.SetFlags(EnProfilerFlags.RECURSIVE | EnProfilerFlags.RESET);
        EnProfiler.ClearFlags();
        
        if (!Assert(EnProfiler.GetFlags() == EnProfilerFlags.NONE))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        // Reset
        EnProfiler.SetFlags(currentFlags);        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Test adding of flags
    TFResult TestAddFlags()
    {
        int currentFlags = EnProfiler.GetFlags();
                        
        EnProfiler.ClearFlags();
        
        // Return should match resulting flags
        if (!Assert(EnProfiler.AddFlags(EnProfilerFlags.RESET) == EnProfiler.GetFlags()))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(EnProfiler.GetFlags() == EnProfilerFlags.RESET))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(EnProfiler.AddFlags(EnProfilerFlags.RECURSIVE) == (EnProfilerFlags.RESET | EnProfilerFlags.RECURSIVE)))
        {
            EnProfiler.SetFlags(currentFlags);
            return NTFR(TFR.FAIL);
        }
        
        // Reset
        EnProfiler.SetFlags(currentFlags);        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Test module
    TFResult TestModule()
    {
        // File lives in Game, use it while testing
        const EnProfilerModule eptModule = EnProfilerModule.GAME;
        
        // This was added at the same time as this API, so check if it works as well
        string nameOfCurrentModule = Type().GetModule();
        if (!Assert(nameOfCurrentModule != ""))
        {
            return NTFR(TFR.FAIL);
        }
        
        // We know we are in Game, so use it as a test
        EnProfilerModule currentModule;
        if (!Assert(EnProfiler.NameToModule(nameOfCurrentModule, currentModule)))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(currentModule == eptModule))
        {
            return NTFR(TFR.FAIL);
        }
        
        // Test if setting and getting works
        EnProfilerModule currentlyProfiledModule = EnProfiler.GetModule();       
        EnProfiler.SetModule(eptModule);     
        
        if (!Assert(EnProfiler.GetModule() == eptModule))
        {
            EnProfiler.SetModule(currentlyProfiledModule);
            return NTFR(TFR.FAIL);
        }
        
        // Data to restore
        int currentFlags = EnProfiler.GetFlags();
        bool wasEnabled = EnProfiler.RequestImmediateData();
        
        // Make sure we are only profiling Game and that the data is clean
        // Only valid for the Get...Per... methods, as they need to be sorted
        EnProfiler.RemoveFlags(EnProfilerFlags.RECURSIVE);
        
        // GetTickTime() returns in seconds, so gather the results in seconds too
        int resolution = EnProfiler.GetTimeResolution();
        EnProfiler.SetTimeResolution(1);
        
        // Time to sleeb
        float previousTime = EnProfiler.GetTimeOfFunc("Sleep", Type(), true);
        float timeSlept = Sleep(0.3);
        float postTime = EnProfiler.GetTimeOfFunc("Sleep", Type(), true);
        float diff = postTime - previousTime - timeSlept;
        
        // Restore
        EnProfiler.SetTimeResolution(resolution);        
        
        // We called the function, so it must have some time
        if (!Assert(postTime > 0))
        {
            EnProfiler.SetFlags(currentFlags);
            
            if (!wasEnabled)
                EnProfiler.Enable(false, true);
            
            EnProfiler.SetModule(currentlyProfiledModule);
            
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(diff < 0.00001))
        {
            EnProfiler.SetFlags(currentFlags);            
            
            if (!wasEnabled)
                EnProfiler.Enable(false, true);
            
            EnProfiler.SetModule(currentlyProfiledModule);
            
            return NTFR(TFR.FAIL);
        }
        
        // Clean the session
        EnProfiler.ResetSession(true);
        
        // Something from a different module should not get sorted, so just fire something from a different module
        for (int i = 0; i < 1000; ++i)
        {
            EnumTools.StringToEnum(EnProfilerModule, "MISSION_CUSTOM");
        }
        
        // Sort and gather the data and validate if it is correct
        EnProfiler.SortData();    
        array<ref EnProfilerTimeFuncPair> timePerFunc = {};
        EnProfiler.GetTimePerFunc(timePerFunc);
        
        Debug.TFLog("Game fncs:", this, "TestModule");
        
        int funcCount = timePerFunc.Count();
        for (int j = 0; j < funcCount; ++j)
        {
            EnProfilerTimeFuncPair tfp = timePerFunc[j];
            Debug.TFLog(string.Format("   time: %1 | fnc: %2", tfp.param1, tfp.param2), this, "TestModule");
            // We are currently profiling Game, so this Core function shouldn't be present
            if (!Assert(tfp.param2 != "EnumTools::StringToEnum"))
            {
                EnProfiler.SetFlags(currentFlags);
                
                if (!wasEnabled)
                    EnProfiler.Enable(false, true);
                
                EnProfiler.SetModule(currentlyProfiledModule);
                
                return NTFR(TFR.FAIL);
            }
        }
        
        array<ref EnProfilerTimeClassPair> timePerClass = {};
        EnProfiler.GetTimePerClass(timePerClass);
        
        int classCount = timePerClass.Count();
        for (int k = 0; k < classCount; ++k)
        {
            typename type = timePerClass[k].param2;
            EnProfilerModule classModule;
            if (!Assert(EnProfiler.NameToModule(type.GetModule(), classModule)))
            {
                EnProfiler.SetFlags(currentFlags);
                
                if (!wasEnabled)
                    EnProfiler.Enable(false, true);
                
                EnProfiler.SetModule(currentlyProfiledModule);
                
                return NTFR(TFR.FAIL);
            }
            
            // Only classes from Game should be present
            if (!Assert(classModule == eptModule))
            {
                EnProfiler.SetFlags(currentFlags);
                
                if (!wasEnabled)
                    EnProfiler.Enable(false, true);
                
                EnProfiler.SetModule(currentlyProfiledModule);
                
                return NTFR(TFR.FAIL);
            }
        }
        
        // Now let's check if we can gather the data of what we called earlier by switching the profiled module without resetting the session
        EnProfiler.SetModule(EnProfilerModule.CORE, false);
        EnProfiler.SortData();
        timePerFunc.Clear(); // Let's reuse the array, but the Get...Per... methods only appends to the array, clearing is our responsibility
        EnProfiler.GetTimePerFunc(timePerFunc);
        
        bool found = false;
        
        Debug.TFLog("Core fncs:", this, "TestModule");
        
        funcCount = timePerFunc.Count();
        for (int l = 0; l < funcCount; ++l)
        {
            EnProfilerTimeFuncPair tfpc = timePerFunc[l];
            Debug.TFLog(string.Format("   time: %1 | fnc: %2", tfpc.param1, tfpc.param2), this, "TestModule");
            // We are currently profiling Core, so this Core function should be present
            if (tfpc.param2 == "EnumTools::StringToEnum")
            {
                found = true;
                break;
            }
        }
        
        Assert(found);
        
        // Test some bogus
        EnProfilerModule mod = EnProfiler.GetModule();
        EnProfiler.SetModule(-333);
        bool success = Assert(EnProfiler.GetModule() == mod);
        EnProfiler.SetModule(6003);
        success &= Assert(EnProfiler.GetModule() == mod);
        
        EnProfiler.SetFlags(currentFlags);
        EnProfiler.SetModule(currentlyProfiledModule);
        
        if (!wasEnabled)
            EnProfiler.Enable(false, true);
        
        return BTFR(success && found);
    }
    
    //---------------------------------------------------------------------------
    // Test to see if class time data is correct
    TFResult TestClassTimeData()
    {
        // We should restore this when done
        int resolution = EnProfiler.GetTimeResolution();
        bool wasEnabled = EnProfiler.RequestImmediateData();
        
        // GetTickTime() returns in seconds, so gather the results in seconds too
        EnProfiler.SetTimeResolution(1);
        
        // Create the classes
        EPTHelperClass clss = new EPTHelperClass();
        
        // Time to stress
        float previousTime = EnProfiler.GetTimeOfClass(clss.Type(), true);
        float timeStressed = clss.DoEverything();
        float postTime =  EnProfiler.GetTimeOfClass(clss.Type(), true);
        float postTimeStatic = EnProfiler.GetTimeOfClass(StaticGetType(EPTHelperClass), true);
        float timeProfiled = postTime - previousTime;
        float diff = Math.AbsFloat(timeProfiled - timeStressed);
        
        Debug.TFLog(string.Format("Profiling result: stressed: %1 | profiled: %2 | diff: %3", timeStressed, timeProfiled, diff), this, "TestClassTimeData");
        
        // Restore
        EnProfiler.SetTimeResolution(resolution);
        if (!wasEnabled)
            EnProfiler.Enable(false, true);
        
        // We called the function, so it must have some time
        if (!Assert(postTime > 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(postTime == postTimeStatic))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(diff < 0.001))
        {
            return NTFR(TFR.FAIL);
        }
        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Test to see if class count data is correct
    TFResult TestClassCountData()
    {
        const int allocAmount = 9;
        const int releaseAmount = 6;
        int remainingAmount = allocAmount - releaseAmount;
        
        // We should restore this when done
        bool wasEnabled = EnProfiler.RequestImmediateData();
        
        // Time to test
        int previousAlloc = EnProfiler.GetAllocationsOfClass(StaticGetType(EPTHelperClass), true);
        int previousInstances = EnProfiler.GetInstancesOfClass(StaticGetType(EPTHelperClass), true);
 
        array<ref EPTHelperClass> instanceArr = {};
        for (int i = 0; i < allocAmount; ++i)
        {
            instanceArr.Insert(new EPTHelperClass());
        }
        
        for (int j = 0; j < releaseAmount; ++j)
        {
            delete instanceArr[j];
        }
        
        int postAlloc = EnProfiler.GetAllocationsOfClass(StaticGetType(EPTHelperClass), true);
        int postInstances = EnProfiler.GetInstancesOfClass(StaticGetType(EPTHelperClass), true);
        
        int alloced = postAlloc - previousAlloc;
        int instances = postInstances - previousInstances;
        
        Debug.TFLog(string.Format("Profiling result: alloc: %1 | instances: %2", alloced, instances), this, "TestClassCountData");
        
        // Restore
        if (!wasEnabled)
            EnProfiler.Enable(false, true);
        
        // Time to check
        if (!Assert(alloced == allocAmount))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(instances == remainingAmount))
        {
            return NTFR(TFR.FAIL);
        }
        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Test to see if func time data is correct
    TFResult TestFuncTimeData()
    {
        // We should restore this when done
        int resolution = EnProfiler.GetTimeResolution();
        bool wasEnabled = EnProfiler.RequestImmediateData();
        
        // GetTickTime() returns in seconds, so gather the results in seconds too
        EnProfiler.SetTimeResolution(1);
        
        // Time to stress
        float previousTime = EnProfiler.GetTimeOfFunc("StringFormat", Type(), true);
        float timeStressed = StringFormat();
        float postTime = EnProfiler.GetTimeOfFunc("StringFormat", Type(), true);
        float timeProfiled = postTime - previousTime;
        float diff = Math.AbsFloat(timeProfiled - timeStressed);
        
        float previousTime2 = EnProfiler.GetTimeOfFunc("StringConcat", Type(), true);
        float timeStressed2 = StringConcat();
        float postTime2 = EnProfiler.GetTimeOfFunc("StringConcat", Type(), true);
        float timeProfiled2 = postTime2 - previousTime2;
        float diff2 = Math.AbsFloat(timeProfiled2 - timeStressed2);
        
        Debug.TFLog(string.Format("Profiling result: StringFormat: %1 | StringConcat: %2", timeProfiled, timeProfiled2), this, "TestFuncTimeData");
        
        // Restore
        EnProfiler.SetTimeResolution(resolution);
        if (!wasEnabled)
        {
            EnProfiler.Enable(false, true);
        }
        
        // We called the function, so it must have some time
        if (!Assert(postTime > 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(diff < 0.001))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(postTime2 > 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        if (!Assert(diff2 < 0.001))
        {
            return NTFR(TFR.FAIL);
        }
        
        // I know that string.Format is faster than additive concatenation
        if (!Assert(timeProfiled < timeProfiled2))
        {
            return NTFR(TFR.FAIL);
        }
        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Test to see if func count data is correct
    TFResult TestFuncCountData()
    {
        // We should restore this when done
        bool wasEnabled = EnProfiler.RequestImmediateData();
        
        // Time to count        
        
        // - CallFunction
        int previousCountCF = EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        GetGame().GameScript.CallFunction(this, "TestFuncCountDataHelper", null, 0);
        int postCountCF = EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        
        int callCountCF = postCountCF - previousCountCF;
        
        // - CallFunctionParams
        int previousCountCFP = EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        GetGame().GameScript.CallFunctionParams(this, "TestFuncCountDataHelper", null, null);
        int postCountCFP =  EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        
        int callCountCFP = postCountCFP - previousCountCFP;
        
        // - Regular call
        int previousCountRG = EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        TestFuncCountDataHelper();
        int postCountRG =  EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        
        int callCountRG = postCountRG - previousCountRG;
        
        // - Call
        int previousCountC = EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        GetGame().GameScript.Call(this, "TestFuncCountDataHelper", 0);
        int postCountC =  EnProfiler.GetCountOfFunc("TestFuncCountDataHelper", Type(), true);
        
        int callCountC = postCountC - previousCountC;
        
        // - Garbage        
        int callCountNon = EnProfiler.GetCountOfFunc("Non Existing Method", Type(), true);
        
        // - Static
        int previousCountS = EnProfiler.GetCountOfFunc("TestFuncCountDataHelperStatic", Type(), true);
        TestFuncCountDataHelperStatic();
        int postCountS = EnProfiler.GetCountOfFunc("TestFuncCountDataHelperStatic", Type(), true);
        
        int callCountS = postCountS - previousCountS;
        
        // - Global
        int previousCountG = EnProfiler.GetCountOfFuncG("GetDayZGame", true);
        GetDayZGame();
        int postCountG = EnProfiler.GetCountOfFuncG("GetDayZGame", true);
    
        int callCountG = postCountG - previousCountG;
        
        // - Global proto
        // Not tracked, so don't need to compare before and after, should always be 0
        ErrorEx("Testing global proto call", ErrorExSeverity.INFO);
        int callCountGP = EnProfiler.GetCountOfFuncG("ErrorEx", true);
        
        // - Static proto
        // Not tracked, so don't need to compare before and after, should always be 0
        int callCountSP = EnProfiler.GetCountOfFunc("GetCountOfFunc", StaticGetType(EnProfiler), true);
        
        // - proto
        // Not tracked, so don't need to compare before and after, should always be 0
        GetGame().GetHostName();
        int callCountP = EnProfiler.GetCountOfFunc("GetHostName", GetGame().Type(), true);
        
        // - proto native
        // Not tracked, so don't need to compare before and after, should always be 0
        GetGame().IsServer();
        int callCountPN = EnProfiler.GetCountOfFunc("IsServer", GetGame().Type(), true);
        
        // - static proto native
        // Not tracked, so don't need to compare before and after, should always be 0
        ErrorModuleHandler.GetInstance();
        int callCountSPN = EnProfiler.GetCountOfFunc("GetInstance", StaticGetType(ErrorModuleHandler), true);
        
        // Restore
        if (!wasEnabled)
        {
            EnProfiler.Enable(false, true);
        }
        
        // Do the checks
        
        // - CallFunction
        if (!Assert(callCountCF == 1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - CallFunctionParams
        if (!Assert(callCountCFP == 1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Regular call
        if (!Assert(callCountRG == 1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Call
        if (!Assert(callCountC == 1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Garbage
        if (!Assert(callCountNon == -1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Static
        if (!Assert(callCountS == 1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Global
        if (!Assert(callCountG == 1))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Global proto
        if (!Assert(callCountGP == 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - Static proto
        if (!Assert(callCountSP == 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - proto
        if (!Assert(callCountP == 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - proto native
        if (!Assert(callCountPN == 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        // - static proto native
        if (!Assert(callCountSPN == 0))
        {
            return NTFR(TFR.FAIL);
        }
        
        return NTFR(TFR.SUCCESS);
    }
    
    //---------------------------------------------------------------------------
    // Helpers
    //---------------------------------------------------------------------------
    // Snore
    float Sleep(float timeS)
    {       
        float startTime = GetGame().GetTickTime();
        while (GetGame().GetTickTime() - startTime < timeS)
        {
            // Zzz
        }       
        
        return GetGame().GetTickTime() - startTime;
    }
    
    //---------------------------------------------------------------------------
    // Example stress method
    float StringFormat()
    {       
        float startTime = GetGame().GetTickTime();
        
        for (int i = 0; i < 1000; ++i)
        {
            string example = string.Format("This %1 is %2 just %3 an %4 example %5", i, Type(), this, startTime, "lorem ipsum 1 2 3");
        }   
        
        return GetGame().GetTickTime() - startTime;
    }
    
    //---------------------------------------------------------------------------
    // Example stress method 2
    float StringConcat()
    {       
        float startTime = GetGame().GetTickTime();
        
        for (int i = 0; i < 1000; ++i)
        {
            string example = "This " + i + " is " + Type() + " just " + this + " an " + startTime + " example " + "lorem ipsum 1 2 3";
        }
        
        return GetGame().GetTickTime() - startTime;
    }
    
    //---------------------------------------------------------------------------
    // To make sure it is only ever called in that test
    void TestFuncCountDataHelper()
    {
        int dummy = 3;
    }
    
    //---------------------------------------------------------------------------
    // To make sure it is only ever called in that test
    static void TestFuncCountDataHelperStatic()
    {
        int dummy = 3;
    }
}
 
class EPTHelperClass
{
    float Sleep2(float timeS)
    {       
        float startTime = GetGame().GetTickTime();
        while (GetGame().GetTickTime() - startTime < timeS)
        {
            // Zzz
        }       
        
        return GetGame().GetTickTime() - startTime;
    }
    float SleepAgain(float timeS)
    {       
        float startTime = GetGame().GetTickTime();
        while (GetGame().GetTickTime() - startTime < timeS)
        {
            // Zzz
        }       
        
        return GetGame().GetTickTime() - startTime;
    }
    
    float DoEverything()
    {
        float startTime = GetGame().GetTickTime();
        
        Sleep2(3);
        SleepAgain(3);
        
        return GetGame().GetTickTime() - startTime;
    }
}