EnProfilerTests Class Reference

Inheritance diagram for EnProfilerTests:

Collaboration diagram for EnProfilerTests:

Private Member Functions
void	EnProfilerTests ()
void	~EnProfilerTests ()
TFResult	TestToggling ()
TFResult	TestTogglingImmediate ()
TFResult	TestSetFlags ()
TFResult	TestClearFlags ()
TFResult	TestAddFlags ()
TFResult	TestModule ()
TFResult	TestClassTimeData ()
TFResult	TestClassCountData ()
TFResult	TestFuncTimeData ()
TFResult	TestFuncCountData ()
float	Sleep (float timeS)
float	StringFormat ()
float	StringConcat ()
void	TestFuncCountDataHelper ()

Static Private Member Functions
static void	TestFuncCountDataHelperStatic ()

Private Attributes
bool	m_bWasProfilerEnabled
	Remember this, so we can restore the previous state before the test!

Detailed Description

Definition at line 1 of file EnProfilerTests.c.

Constructor & Destructor Documentation

EnProfilerTests()

void EnProfilerTests::EnProfilerTests ( )

inlineprivate

Definition at line 9 of file EnProfilerTests.c.

  {
    m_bWasProfilerEnabled = EnProfiler.IsEnabledC();
 
    AddInitTest("TestToggling");
    AddInitTest("TestTogglingImmediate");
    AddInitTest("TestSetFlags");
    AddInitTest("TestClearFlags");
    AddInitTest("TestAddFlags");
    AddInitTest("TestModule");
    AddInitTest("TestClassTimeData");
    AddInitTest("TestClassCountData");
    AddInitTest("TestFuncTimeData");
    AddInitTest("TestFuncCountData");
  }

References AddInitTest(), EnProfiler::IsEnabledC(), and m_bWasProfilerEnabled.

~EnProfilerTests()

void EnProfilerTests::~EnProfilerTests ( )

inlineprivate

Definition at line 28 of file EnProfilerTests.c.

  {
    EnProfiler.Enable(m_bWasProfilerEnabled, true);
  }

References EnProfiler::Enable(), and m_bWasProfilerEnabled.

Member Function Documentation

Sleep()

float EnProfilerTests::Sleep ( float timeS )

inlineprivate

Definition at line 647 of file EnProfilerTests.c.

  {
    float startTime = GetGame().GetTickTime();
    while (GetGame().GetTickTime() - startTime < timeS)
    {
      // Zzz
    }
 
    return GetGame().GetTickTime() - startTime;
  }

References GetGame().

Referenced by TestModule().

StringConcat()

float EnProfilerTests::StringConcat ( )

inlineprivate

Definition at line 672 of file EnProfilerTests.c.

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

References GetGame(), and Type.

Referenced by TestFuncTimeData().

StringFormat()

float EnProfilerTests::StringFormat ( )

inlineprivate

Definition at line 660 of file EnProfilerTests.c.

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

References GetGame(), and Type.

Referenced by TestFuncTimeData().

TestAddFlags()

TFResult EnProfilerTests::TestAddFlags ( )

inlineprivate

Definition at line 157 of file EnProfilerTests.c.

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

References EnProfiler::AddFlags(), Assert(), EnProfiler::ClearFlags(), EnProfiler::GetFlags(), NTFR(), and EnProfiler::SetFlags().

TestClassCountData()

TFResult EnProfilerTests::TestClassCountData ( )

inlineprivate

Definition at line 415 of file EnProfilerTests.c.

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

References Assert(), EnProfiler::Enable(), EnProfiler::GetAllocationsOfClass(), EnProfiler::GetInstancesOfClass(), NTFR(), EnProfiler::RequestImmediateData(), and Debug::TFLog().

TestClassTimeData()

TFResult EnProfilerTests::TestClassTimeData ( )

inlineprivate

Definition at line 373 of file EnProfilerTests.c.

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

References Math::AbsFloat(), Assert(), EnProfiler::Enable(), EnProfiler::GetTimeOfClass(), EnProfiler::GetTimeResolution(), NTFR(), EnProfiler::RequestImmediateData(), EnProfiler::SetTimeResolution(), and Debug::TFLog().

TestClearFlags()

TFResult EnProfilerTests::TestClearFlags ( )

inlineprivate

Definition at line 120 of file EnProfilerTests.c.

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

References Assert(), EnProfiler::ClearFlags(), EnProfiler::GetFlags(), NTFR(), EnProfiler::RemoveFlags(), and EnProfiler::SetFlags().

TestFuncCountData()

TFResult EnProfilerTests::TestFuncCountData ( )

inlineprivate

Definition at line 510 of file EnProfilerTests.c.

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

References Assert(), EnProfiler::Enable(), ErrorEx, EnProfiler::GetCountOfFunc(), EnProfiler::GetCountOfFuncG(), GetDayZGame(), GetGame(), ErrorModuleHandler::GetInstance(), NTFR(), EnProfiler::RequestImmediateData(), TestFuncCountDataHelper(), TestFuncCountDataHelperStatic(), and Type.

TestFuncCountDataHelper()

void EnProfilerTests::TestFuncCountDataHelper ( )

inlineprivate

Definition at line 684 of file EnProfilerTests.c.

  {
    int dummy = 3;
  }

Referenced by TestFuncCountData().

TestFuncCountDataHelperStatic()

static void EnProfilerTests::TestFuncCountDataHelperStatic ( )

inlinestaticprivate

Definition at line 691 of file EnProfilerTests.c.

  {
    int dummy = 3;
  }

Referenced by TestFuncCountData().

TestFuncTimeData()

TFResult EnProfilerTests::TestFuncTimeData ( )

inlineprivate

Definition at line 459 of file EnProfilerTests.c.

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

References Math::AbsFloat(), Assert(), EnProfiler::Enable(), EnProfiler::GetTimeOfFunc(), EnProfiler::GetTimeResolution(), NTFR(), EnProfiler::RequestImmediateData(), EnProfiler::SetTimeResolution(), StringConcat(), StringFormat(), Debug::TFLog(), and Type.

TestModule()

TFResult EnProfilerTests::TestModule ( )

inlineprivate

Definition at line 189 of file EnProfilerTests.c.

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

References Assert(), BTFR(), EnProfiler::Enable(), EnProfiler::GetFlags(), EnProfiler::GetModule(), EnProfiler::GetTimeOfFunc(), EnProfiler::GetTimePerClass(), EnProfiler::GetTimePerFunc(), EnProfiler::GetTimeResolution(), EnProfiler::NameToModule(), NTFR(), EnProfiler::RemoveFlags(), EnProfiler::RequestImmediateData(), EnProfiler::ResetSession(), EnProfiler::SetFlags(), EnProfiler::SetModule(), EnProfiler::SetTimeResolution(), Sleep(), EnProfiler::SortData(), EnumTools::StringToEnum(), Debug::TFLog(), and Type.

TestSetFlags()

TFResult EnProfilerTests::TestSetFlags ( )

inlineprivate

Definition at line 67 of file EnProfilerTests.c.

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

References Assert(), EnumTools::GetEnumSize(), EnumTools::GetEnumValue(), EnProfiler::GetFlags(), NTFR(), and EnProfiler::SetFlags().

TestToggling()

TFResult EnProfilerTests::TestToggling ( )

inlineprivate

Definition at line 37 of file EnProfilerTests.c.

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

References Assert(), BTFR(), EnProfiler::Enable(), EnProfiler::IsEnabledP(), and NTFR().

TestTogglingImmediate()

TFResult EnProfilerTests::TestTogglingImmediate ( )

inlineprivate

Definition at line 52 of file EnProfilerTests.c.

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

References Assert(), BTFR(), EnProfiler::Enable(), EnProfiler::IsEnabledC(), and NTFR().

Member Data Documentation

m_bWasProfilerEnabled

bool EnProfilerTests::m_bWasProfilerEnabled

private

Remember this, so we can restore the previous state before the test!

Definition at line 4 of file EnProfilerTests.c.

Referenced by EnProfilerTests(), and ~EnProfilerTests().

---

The documentation for this class was generated from the following file:

• scripts/3_Game/Systems/TFTests/EnProfilerTests.c