diff --git a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_ExtendedTestInformation.cs b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_ExtendedTestInformation.cs
index 8208b4f..7f9c7b8 100644
--- a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_ExtendedTestInformation.cs
+++ b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_ExtendedTestInformation.cs
@@ -9,6 +9,7 @@ public FB_ExtendedTestInformation(IEnumerable<ErrorList.Error> errors, string te
         {
             Check_TestSuite_Statistics();
             AssertTestClassName();
+            AssertTestDuration();
             Test_BOOL_AssertFailed();
             Test_BOOL_AssertSuccess();
             Test_BYTE_TwoFailedAsserts();
@@ -36,6 +37,11 @@ private void AssertTestClassName()
             AssertMessageCount(className, 5, EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
         }
 
+        private void AssertTestDuration()
+        {
+            string duration = "Test duration=%f";
+            AssertMessageCount(duration, 260, EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
+        }
 
         private void Test_BOOL_AssertFailed()
         {
diff --git a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_TestNumberOfAssertionsCalculation.cs b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_TestNumberOfAssertionsCalculation.cs
index 72a2649..b5b6f5f 100644
--- a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_TestNumberOfAssertionsCalculation.cs
+++ b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/FB_TestNumberOfAssertionsCalculation.cs
@@ -16,27 +16,27 @@ public FB_TestNumberOfAssertionsCalculation(IEnumerable<ErrorList.Error> errors,
 
         private void TestMixed33SuccessulAnd9FailedAssertions()
         {
-            AssertContainsMessage("| Test status=FAIL, number of asserts=42", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
+            AssertContainsMessage("| Test status=FAIL, number of asserts=42, duration=%f", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
         }
 
         private void TestWith43SuccessfulAssertions()
         {
-            AssertContainsMessage("| Test status=PASS, number of asserts=43", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
+            AssertContainsMessage("| Test status=PASS, number of asserts=43, duration=%f", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
         }
 
         private void TestWith44FailedAssertions()
         {
-            AssertContainsMessage("| Test status=FAIL, number of asserts=44", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
+            AssertContainsMessage("| Test status=FAIL, number of asserts=44, duration=%f", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
         }
 
         private void TestWith45SuccessfulArrayAssertions()
         {
-            AssertContainsMessage("| Test status=PASS, number of asserts=45", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
+            AssertContainsMessage("| Test status=PASS, number of asserts=45, duration=%f", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
         }
 
         private void TestWith46FailedArrayAssertions()
         {
-            AssertContainsMessage("| Test status=FAIL, number of asserts=46", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
+            AssertContainsMessage("| Test status=FAIL, number of asserts=46, duration=%f", EnvDTE80.vsBuildErrorLevel.vsBuildErrorLevelLow);
         }
 
     }
diff --git a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/Program.cs b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/Program.cs
index 8e231bd..a492134 100644
--- a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/Program.cs
+++ b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/Program.cs
@@ -7,6 +7,7 @@
 using TCatSysManagerLib;
 using System.Threading;
 using EnvDTE80;
+using System.Text.RegularExpressions;
 
 namespace TcUnit.Verifier
 {
@@ -108,8 +109,12 @@ static void Main(string[] args)
             bool numberOfTestsLineFound = false;
             bool numberOfSuccesfulTestsLineFound = false;
             bool numberOfFailedTestsLineFound = false;
+            bool durationLineFound = false;
             bool testsFinishedRunningLastLineFound = false;
             int numberOfFailedTests = 0;
+            float duration;
+
+            const string durationStr = "| Duration:";
 
             log.Info("Waiting for TcUnit-Verifier_TwinCAT to finish running tests...");
 
@@ -139,6 +144,11 @@ static void Main(string[] args)
                         // Grab the number of failed tests so we can validate it during the assertion phase
                         numberOfFailedTests = int.Parse(error.Description.Split().Last());
                     }
+                    if (error.Description.Contains(durationStr))
+                    {
+                        int durationIndex = error.Description.IndexOf(durationStr);
+                        durationLineFound = float.TryParse(error.Description.Substring(durationIndex + durationStr.Length), out duration);
+                    }
                     if (error.Description.Contains("| ======================================"))
                         testsFinishedRunningLastLineFound = true;
                 }
@@ -148,7 +158,8 @@ static void Main(string[] args)
                     && numberOfTestSuitesLineFound 
                     && numberOfTestsLineFound 
                     && numberOfSuccesfulTestsLineFound
-                    && numberOfFailedTestsLineFound 
+                    && numberOfFailedTestsLineFound
+                    && durationLineFound
                     && testsFinishedRunningLastLineFound
                 )
                     break;
diff --git a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/TestFunctionBlockAssert.cs b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/TestFunctionBlockAssert.cs
index 570b305..20e0710 100644
--- a/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/TestFunctionBlockAssert.cs
+++ b/TcUnit-Verifier/TcUnit-Verifier_DotNet/TcUnit-Verifier/TestFunctionBlockAssert.cs
@@ -2,6 +2,7 @@
 using log4net;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace TcUnit.Verifier
 {
@@ -46,12 +47,24 @@ protected string CreateFailedTestMessageNoAssertionMessage(string method, string
 
         private bool AreErrorItemsContainingTestMessage(string testMessage, vsBuildErrorLevel errorLevel)
         {
-            return _errors.Any(e => (e.Description.Contains(testMessage.ToUpper())) && e.ErrorLevel.Equals(errorLevel));
+            // no regex needed, do a fast check
+            if(!testMessage.Contains("%f"))
+                return _errors.Any(e => e.Description.Contains(testMessage.ToUpper()) && e.ErrorLevel.Equals(errorLevel));
+
+            // convert number placeholders (%f) to a regex that matches floating point values
+            testMessage = @".*?" + Regex.Escape(testMessage).Replace("%f", @"[+-]?(\d+([.]\d*)?([eE][+-]?\d+)?|[.]\d+([eE][+-]?\d+)?)") + @".*?";
+            return _errors.Any(e => Regex.Match(e.Description, testMessage, RegexOptions.IgnoreCase).Success && e.ErrorLevel.Equals(errorLevel));
         }
 
         private int CountErrorItemsContainingTestMessage(string testMessage, vsBuildErrorLevel errorLevel)
         {
-            return _errors.Count(s => (s.Description.Contains(testMessage.ToUpper())) && s.ErrorLevel.Equals(errorLevel));
+            // no regex needed, do a fast check
+            if (!testMessage.Contains("%f"))
+                return _errors.Count(e => e.Description.Contains(testMessage.ToUpper()) && e.ErrorLevel.Equals(errorLevel));
+
+            // convert number placeholders (%f) to a regex that matches floating point values
+            testMessage = @".*?" + Regex.Escape(testMessage).Replace("%f", @"[+-]?(\d+([.]\d*)?([eE][+-]?\d+)?|[.]\d+([eE][+-]?\d+)?)") + @".*?";
+            return _errors.Count(e => Regex.Match(e.Description, testMessage, RegexOptions.IgnoreCase).Success && e.ErrorLevel.Equals(errorLevel));
         }
 
         protected void AssertMessageCount(string message, int messageCount, vsBuildErrorLevel errorLevel)
diff --git a/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT b/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT
index 50df1fa..ecabb4f 100644
--- a/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT
+++ b/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT
@@ -10,6 +10,7 @@ STRUCT
     FailureMessage : Tc2_System.T_MaxString;
     FailureType : E_AssertionType;
     NumberOfAsserts : UINT;
+    Duration : LREAL; // in seconds
 END_STRUCT
 END_TYPE]]></Declaration>
   </DUT>
diff --git a/TcUnit/TcUnit/DUTs/ST_TestSuiteResult.TcDUT b/TcUnit/TcUnit/DUTs/ST_TestSuiteResult.TcDUT
index 4e6c70a..db0168b 100644
--- a/TcUnit/TcUnit/DUTs/ST_TestSuiteResult.TcDUT
+++ b/TcUnit/TcUnit/DUTs/ST_TestSuiteResult.TcDUT
@@ -7,6 +7,7 @@ STRUCT
     Identity : UINT(0..GVL_Param_TcUnit.MaxNumberOfTestSuites); // Should be 0..GVL_Param_TcUnit.MaxNumberOfTestSuites-1 but gives unknown compiler error
     NumberOfTests : UINT(0..GVL_Param_TcUnit.MaxNumberOfTestsForEachTestSuite);
     NumberOfFailedTests : UINT(0..GVL_Param_TcUnit.MaxNumberOfTestsForEachTestSuite);
+    Duration : LREAL; // in seconds
     TestCaseResults : ARRAY[1..GVL_Param_TcUnit.MaxNumberOfTestsForEachTestSuite] OF ST_TestCaseResult;
 END_STRUCT
 END_TYPE]]></Declaration>
diff --git a/TcUnit/TcUnit/DUTs/ST_TestSuiteResults.TcDUT b/TcUnit/TcUnit/DUTs/ST_TestSuiteResults.TcDUT
index ffdd1c6..cec09d8 100644
--- a/TcUnit/TcUnit/DUTs/ST_TestSuiteResults.TcDUT
+++ b/TcUnit/TcUnit/DUTs/ST_TestSuiteResults.TcDUT
@@ -8,7 +8,8 @@ STRUCT
     NumberOfTestCases : UINT; // The total number of test cases (for all test suites)
     NumberOfSuccessfulTestCases : UINT; // The total number of test cases that had all ASSERTS successful
     NumberOfFailedTestCases : UINT; // The total number of test cases that had at least one ASSERT failed
-
+    Duration : LREAL; // Duration it took for all test suites to finish, in seconds
+    
     (* Test results for each individiual test suite *)
     TestSuiteResults : ARRAY[1..GVL_Param_TcUnit.MaxNumberOfTestSuites] OF ST_TestSuiteResult;
 END_STRUCT
diff --git a/TcUnit/TcUnit/GVLs/GVL_TcUnit.TcGVL b/TcUnit/TcUnit/GVLs/GVL_TcUnit.TcGVL
index a5393bb..b853da2 100644
--- a/TcUnit/TcUnit/GVLs/GVL_TcUnit.TcGVL
+++ b/TcUnit/TcUnit/GVLs/GVL_TcUnit.TcGVL
@@ -14,6 +14,15 @@ VAR_GLOBAL
 
     (* Current name of test being called *)
     CurrentTestNameBeingCalled : Tc2_System.T_MaxString;
+	
+    (* Used to get the current cpu cycle counter to calculate the duration of tests and test suits, respectively *)
+    GetCpuCounter : Tc2_System.GETCPUCOUNTER;
+    
+    (* Stores the CPU cycle count with 100ns precision since the first entry into one of the Run methods (RUN, RUN_IN_SEQUENCE) *)
+    StartedAt : LWORD;
+    
+    (* Duration it took for a complete run, in seconds *)
+    Duration : LREAL;    
 
     (* Whether or not the current test being called has finished running *)
     CurrentTestIsFinished : BOOL;
@@ -35,6 +44,11 @@ VAR_GLOBAL
 
     (* Buffered ADS message queue for output to the error list *)
     AdsMessageQueue : FB_AdsLogStringMessageFifoQueue;
+END_VAR
+VAR_GLOBAL CONSTANT
+  (* Multiply a value that is given in 100ns units by this value to
+     convert the value to seconds *)
+  HundredNanosecondToSecond : LREAL := 1.0 / 10000000.0;
 END_VAR]]></Declaration>
   </GVL>
 </TcPlcObject>
\ No newline at end of file
diff --git a/TcUnit/TcUnit/POUs/FB_AdsTestResultLogger.TcPOU b/TcUnit/TcUnit/POUs/FB_AdsTestResultLogger.TcPOU
index d3837df..4766631 100644
--- a/TcUnit/TcUnit/POUs/FB_AdsTestResultLogger.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_AdsTestResultLogger.TcPOU
@@ -74,7 +74,11 @@ IF PrintingTestSuiteResultNumber <= GVL_TcUnit.NumberOfInitializedTestSuites AND
                                              STR2 := ', number of failed tests=');
         StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint,
                                              STR2 := UINT_TO_STRING(TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].NumberOfFailedTests));
-
+        StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint,
+                                             STR2 := ', duration=');
+        StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint,
+                                             STR2 := LREAL_TO_STRING(TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].Duration));
+											 
         GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_HINT,
                                             MsgFmtStr := StringToPrint,
                                             StrArg := '');
@@ -96,7 +100,11 @@ IF PrintingTestSuiteResultNumber <= GVL_TcUnit.NumberOfInitializedTestSuites AND
             GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_HINT,
                                                 MsgFmtStr := '| Test class name=%s',
                                                 StrArg := TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].TestClassName);
-
+            (* Print test duration *)
+            GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_HINT,
+                                                MsgFmtStr := '| Test duration=%s',
+                                                StrArg := LREAL_TO_STRING(TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].Duration));
+            
             (* Print test result/status (SUCCESS, FAILED, SKIPPED) + number of assertions made *)
             IF TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].TestIsFailed THEN
                 StringToPrint := Tc2_Standard.CONCAT(STR1 := '| Test status=', STR2 := TEST_STATUS_FAIL);
@@ -109,6 +117,9 @@ IF PrintingTestSuiteResultNumber <= GVL_TcUnit.NumberOfInitializedTestSuites AND
             StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint, STR2 := ', number of asserts=');
             StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint, STR2 :=
                                                  UINT_TO_STRING(TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].NumberOfAsserts));
+            StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint, STR2 := ', duration=');
+            StringToPrint := Tc2_Standard.CONCAT(STR1 := StringToPrint, STR2 :=
+                                                 LREAL_TO_STRING(TcUnitTestResults.TestSuiteResults[PrintingTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].Duration));												 
             GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_HINT,
                                                 MsgFmtStr := StringToPrint,
                                                 StrArg := '');
@@ -168,6 +179,9 @@ IF (GVL_TcUnit.NumberOfInitializedTestSuites = 0 OR PrintingTestSuiteResultNumbe
     GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_ERROR,
                                         MsgFmtStr := '| Failed tests: %s',
                                         StrArg := UINT_TO_STRING(TcUnitTestResults.NumberOfFailedTestCases));
+    GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_ERROR,
+                                        MsgFmtStr := '| Duration: %s',
+                                        StrArg := LREAL_TO_STRING(TcUnitTestResults.Duration));                                        
     GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_ERROR,
                                         MsgFmtStr := '%s',
                                         StrArg := '| ======================================');
diff --git a/TcUnit/TcUnit/POUs/FB_TcUnitRunner.TcPOU b/TcUnit/TcUnit/POUs/FB_TcUnitRunner.TcPOU
index bf8a2d3..57b0107 100644
--- a/TcUnit/TcUnit/POUs/FB_TcUnitRunner.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_TcUnitRunner.TcPOU
@@ -8,6 +8,7 @@ FUNCTION_BLOCK FB_TcUnitRunner
 VAR
     (* Indication of whether all test suites have reported that they are finished *)
     AllTestSuitesFinished : BOOL := FALSE;
+    AllTestSuitesFinishedTrigger : R_TRIG;
 
     (* Test result information *)
     TestResults : FB_TestResults;
@@ -49,7 +50,11 @@ VAR
     NumberOfTestSuitesFinished : UINT := 0;
 END_VAR]]></Declaration>
       <Implementation>
-        <ST><![CDATA[(* Run TcUnit test suites *)
+        <ST><![CDATA[IF GVL_TcUnit.StartedAt = 0 THEN
+    GVL_TcUnit.StartedAt := F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter);
+END_IF
+
+(* Run TcUnit test suites *)
 IF NOT AllTestSuitesFinished THEN
     IF GVL_TcUnit.NumberOfInitializedTestSuites = 0 THEN
         AllTestSuitesFinished := TRUE;
@@ -61,6 +66,7 @@ IF NOT AllTestSuitesFinished THEN
                 GVL_TcUnit.CurrentTestSuiteBeingCalled := GVL_TcUnit.TestSuiteAddresses[Counter];
                 GVL_TcUnit.CurrentTestSuiteBeingCalled^.SetHasStartedRunning();
                 GVL_TcUnit.CurrentTestSuiteBeingCalled^();
+                GVL_TcUnit.CurrentTestSuiteBeingCalled^.UpdateDuration();
             END_IF
         END_FOR
         (* Check if some event triggered an abortion of running the tests, in that case abort it now.
@@ -68,12 +74,20 @@ IF NOT AllTestSuitesFinished THEN
         IF AbortRunningTestSuites THEN
             NumberOfTestSuitesFinished := GVL_TcUnit.NumberOfInitializedTestSuites;
         END_IF
+        
         IF NumberOfTestSuitesFinished = GVL_TcUnit.NumberOfInitializedTestSuites THEN
             AllTestSuitesFinished := TRUE;
         END_IF
     END_IF
 END_IF
 
+(* Measure the duration it took to run all testsuites *)
+AllTestSuitesFinishedTrigger(CLK := AllTestSuitesFinished);
+IF AllTestSuitesFinishedTrigger.Q
+THEN
+    GVL_TcUnit.Duration := LWORD_TO_LREAL(F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter) - GVL_TcUnit.StartedAt) * GVL_TcUnit.HundredNanosecondToSecond; // seconds
+END_IF
+
 (* Store test suite results continuously *)
 TestResults();
 
@@ -108,7 +122,11 @@ VAR_INST
      TimerBetweenExecutionOfTestSuites : Tc2_Standard.TOF;
 END_VAR]]></Declaration>
       <Implementation>
-        <ST><![CDATA[TimerBetweenExecutionOfTestSuites(PT := TimeBetweenTestSuitesExecution);
+        <ST><![CDATA[IF GVL_TcUnit.StartedAt = 0 THEN
+    GVL_TcUnit.StartedAt := F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter);
+END_IF
+
+TimerBetweenExecutionOfTestSuites(PT := TimeBetweenTestSuitesExecution);
 (* Run TcUnit test suites *)
 IF NOT AllTestSuitesFinished THEN
     IF GVL_TcUnit.NumberOfInitializedTestSuites = 0 THEN
@@ -127,6 +145,7 @@ IF NOT AllTestSuitesFinished THEN
             GVL_TcUnit.CurrentTestSuiteBeingCalled := GVL_TcUnit.TestSuiteAddresses[CurrentlyRunningTestSuite];
             GVL_TcUnit.CurrentTestSuiteBeingCalled^.SetHasStartedRunning();
             GVL_TcUnit.CurrentTestSuiteBeingCalled^();
+            GVL_TcUnit.CurrentTestSuiteBeingCalled^.UpdateDuration();
         END_IF
         (* Check if some event triggered an abortion of running the tests, in that case abort it now.
            This can be accomplished by setting the result of the test suites run to finished. *)
@@ -139,6 +158,13 @@ IF NOT AllTestSuitesFinished THEN
     END_IF
 END_IF
 
+(* Measure the duration it took to run all testsuites *)
+AllTestSuitesFinishedTrigger(CLK := AllTestSuitesFinished);
+IF AllTestSuitesFinishedTrigger.Q
+THEN
+    GVL_TcUnit.Duration := LWORD_TO_LREAL(F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter) - GVL_TcUnit.StartedAt) * GVL_TcUnit.HundredNanosecondToSecond; // seconds
+END_IF
+
 (* Store test suite results continuously *)
 TestResults();
 
diff --git a/TcUnit/TcUnit/POUs/FB_Test.TcPOU b/TcUnit/TcUnit/POUs/FB_Test.TcPOU
index 96cf10e..6077def 100644
--- a/TcUnit/TcUnit/POUs/FB_Test.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_Test.TcPOU
@@ -20,6 +20,9 @@ VAR
     TestIsFailed : BOOL; // Indication of whether this test has at least one failed assert
     AssertionMessage : Tc2_System.T_MaxString; // Assertion message for the first assertion in this test
     AssertionType : E_AssertionType; // Assertion type for the first assertion in this test
+
+    StartedAt : LWORD; // Temporary variable to calculate the actual duration of the test, the value holds the cpu cycle counter when a test is started in 100ns precision
+    Duration : LREAL; // Duration of the test in seconds
 END_VAR]]></Declaration>
     <Implementation>
       <ST><![CDATA[]]></ST>
@@ -36,6 +39,12 @@ END_VAR]]></Declaration>
         <ST><![CDATA[GetAssertionType := AssertionType;]]></ST>
       </Implementation>
     </Method>
+    <Method Name="GetDuration" Id="{3e6c864c-e46e-4560-84e2-e90d42108999}">
+      <Declaration><![CDATA[METHOD INTERNAL GetDuration : LREAL]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[GetDuration := Duration;]]></ST>
+      </Implementation>
+    </Method>
     <Method Name="GetName" Id="{94757f0e-9979-49d0-ad9f-e35c823175d4}">
       <Declaration><![CDATA[METHOD INTERNAL GetName : Tc2_System.T_MaxString;]]></Declaration>
       <Implementation>
@@ -104,9 +113,13 @@ END_IF]]></ST>
       </Implementation>
     </Method>
     <Method Name="SetFinished" Id="{e1245d1c-be22-4d60-bc91-fe0262827234}">
-      <Declaration><![CDATA[METHOD INTERNAL SetFinished : BOOL]]></Declaration>
+      <Declaration><![CDATA[METHOD INTERNAL SetFinished : BOOL
+VAR_INPUT
+    FinishedAt : LWORD; // CPU cycle counter with 100ns precision 
+END_VAR]]></Declaration>
       <Implementation>
-        <ST><![CDATA[TestIsFinished := TRUE;]]></ST>
+        <ST><![CDATA[TestIsFinished := TRUE;
+Duration := LWORD_TO_LREAL(FinishedAt - StartedAt) * GVL_TcUnit.HundredNanosecondToSecond; // seconds]]></ST>
       </Implementation>
     </Method>
     <Method Name="SetName" Id="{4c12f6eb-bbe4-4872-ac89-4411e2e81414}">
@@ -134,6 +147,18 @@ METHOD INTERNAL SetSkipped]]></Declaration>
         <ST><![CDATA[TestIsSkipped := TRUE;]]></ST>
       </Implementation>
     </Method>
+    <Method Name="SetStartedAtIfNotSet" Id="{35bcf245-cc42-44cc-8963-d5986e3acc7f}">
+      <Declaration><![CDATA[METHOD INTERNAL SetStartedAtIfNotSet
+VAR_INPUT
+    Timestamp : LWORD; // CPU cycle counter with 100ns precision 
+END_VAR
+]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[IF StartedAt = 0 THEN
+    StartedAt := Timestamp;
+END_IF]]></ST>
+      </Implementation>
+    </Method>
     <Method Name="SetTestOrder" Id="{9154b373-5715-4bb9-b58b-0dd484b21841}">
       <Declaration><![CDATA[(* Sets in which order/sequence relative to the order tests should this test be executed/evaluated. *)
 METHOD INTERNAL SetTestOrder
diff --git a/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU b/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU
index c0438c4..39f520a 100644
--- a/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU
@@ -43,6 +43,10 @@ IF StoringTestSuiteResultNumber <= GVL_TcUnit.NumberOfInitializedTestSuites AND
         TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].NumberOfFailedTests :=
             GVL_TcUnit.TestSuiteAddresses[StoringTestSuiteResultNumber]^.GetNumberOfFailedTests();
 
+        (* Store the duration *)
+        TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].Duration :=
+            GVL_TcUnit.TestSuiteAddresses[StoringTestSuiteResultNumber]^.GetDuration();
+
         (* Limit the test analyse to the max array limit of 'Tests[]' in FB_TestSuite *)
         NumberOfTestsToAnalyse := GVL_TcUnit.TestSuiteAddresses[StoringTestSuiteResultNumber]^.GetNumberOfTestsToAnalyse();
 
@@ -75,6 +79,10 @@ IF StoringTestSuiteResultNumber <= GVL_TcUnit.NumberOfInitializedTestSuites AND
             (* Store number of assertions made *)
             TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].NumberOfAsserts :=
                 TestToBeStored.GetNumberOfAssertions();
+
+            (* Store the duration of the test *)
+            TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].Duration :=
+                TestToBeStored.GetDuration();
         END_FOR
 
         IF StoringTestSuiteResultNumber = GVL_TcUnit.NumberOfInitializedTestSuites THEN
@@ -94,6 +102,7 @@ IF GVL_TcUnit.NumberOfInitializedTestSuites = 0 AND (NOT StoredGeneralTestResult
 ELSIF StoringTestSuiteResultNumber = GVL_TcUnit.NumberOfInitializedTestSuites AND_THEN
     GVL_TcUnit.TestSuiteAddresses[StoringTestSuiteResultNumber]^.AreAllTestsFinished() AND StoredTestSuiteResults AND (NOT StoredGeneralTestResults) THEN
     TestSuiteResults.NumberOfTestSuites := GVL_TcUnit.NumberOfInitializedTestSuites;
+    TestSuiteResults.Duration := GVL_TcUnit.Duration;
     FOR GeneralTestResultsTestSuitesCounter := 1 TO GVL_TcUnit.NumberOfInitializedTestSuites BY 1 DO
         TestSuiteResults.NumberOfTestCases := TestSuiteResults.NumberOfTestCases + TestSuiteResults.TestSuiteResults[GeneralTestResultsTestSuitesCounter].NumberOfTests;
         TestSuiteResults.NumberOfSuccessfulTestCases := TestSuiteResults.NumberOfSuccessfulTestCases +
diff --git a/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU b/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU
index a8bdb43..2358195 100644
--- a/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU
@@ -37,8 +37,13 @@ VAR
     AdsAssertMessageFormatter : FB_AdsAssertMessageFormatter;
     AssertMessageFormatter : I_AssertMessageFormatter := AdsAssertMessageFormatter;
 
-    (* Indication whether this test suite has started running its tests *)
-    HasStartedRunning : BOOL;
+    (* Stores the CPU cycle count with 100ns precision. It also is an indication whether this 
+       test suite has started running its tests*)
+    StartedAt : LWORD;
+    
+    (* Duration it took to run all tests in this testsuite - including the overhead from TcUnit
+       in seconds *)
+    Duration : LREAL;
 
     (* Number of ordered tests (created by TEST_ORDERED()) that this test suite contains *)
     NumberOfOrderedTests : UINT(0..GVL_Param_TcUnit.MaxNumberOfTestsForEachTestSuite);
@@ -47,7 +52,7 @@ END_VAR]]></Declaration>
       <ST><![CDATA[]]></ST>
     </Implementation>
     <Method Name="AddTest" Id="{d383011f-6bea-4b05-9018-ea4782ad2837}">
-      <Declaration><![CDATA[METHOD INTERNAL AddTest
+      <Declaration><![CDATA[METHOD INTERNAL AddTest : REFERENCE TO FB_Test
 VAR_INPUT
     TestName : Tc2_System.T_MaxString;
     IsTestOrdered : BOOL;
@@ -132,7 +137,9 @@ END_IF
 IF IgnoreCurrentTestCase THEN
     GVL_TcUnit.IgnoreCurrentTest := TRUE;
     RETURN;
-END_IF]]></ST>
+END_IF
+
+AddTest REF= GetTestByName(TrimmedTestName);]]></ST>
       </Implementation>
     </Method>
     <Method Name="AddTestNameToInstancePath" Id="{abecfe2f-b0e2-4118-a1c6-bb248556b776}">
@@ -3642,10 +3649,16 @@ METHOD PRIVATE FindTestSuiteInstancePath : Tc2_System.T_MaxString]]></Declaratio
         <ST><![CDATA[FindTestSuiteInstancePath := GetInstancePath();]]></ST>
       </Implementation>
     </Method>
+    <Method Name="GetDuration" Id="{c5d72850-806c-4a5f-a535-d97d667b1fa5}">
+      <Declaration><![CDATA[METHOD INTERNAL GetDuration : LREAL]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[GetDuration := Duration;]]></ST>
+      </Implementation>
+    </Method>
     <Method Name="GetHasStartedRunning" Id="{73f869b5-0951-4519-8e1e-dd573837cf2e}">
       <Declaration><![CDATA[METHOD INTERNAL GetHasStartedRunning : BOOL]]></Declaration>
       <Implementation>
-        <ST><![CDATA[GetHasStartedRunning := HasStartedRunning;]]></ST>
+        <ST><![CDATA[GetHasStartedRunning := StartedAt > 0;]]></ST>
       </Implementation>
     </Method>
     <Method Name="GetInstancePath" Id="{178fa338-5ed3-417b-8f4d-e9f120ace4b9}">
@@ -3717,6 +3730,26 @@ GetNumberOfSkippedTests := SkippedTestsCount;]]></ST>
         <ST><![CDATA[GetNumberOfTestsToAnalyse := MIN(GetNumberOfTests(), GVL_Param_TcUnit.MaxNumberOfTestsForEachTestSuite);]]></ST>
       </Implementation>
     </Method>
+    <Method Name="GetTestByName" Id="{916a82c5-2376-4d6f-a61d-edc725255e83}">
+      <Declaration><![CDATA[METHOD GetTestByName : REFERENCE TO FB_Test
+VAR_INPUT
+  TestName : Tc2_System.T_MaxString;
+END_VAR
+VAR
+  IteratorCounter : UINT;
+  NumberOfTestsToAnalyse : UINT(1..GVL_Param_TcUnit.MaxNumberOfTestSuites);
+END_VAR
+]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[NumberOfTestsToAnalyse := GetNumberOfTestsToAnalyse();
+FOR IteratorCounter := 1 TO NumberOfTestsToAnalyse BY 1 DO
+  IF Tests[IteratorCounter].GetName() = TestName THEN
+    GetTestByName REF= Tests[IteratorCounter];
+    RETURN;
+	END_IF
+END_FOR]]></ST>
+      </Implementation>
+    </Method>
     <Method Name="GetTestByPosition" Id="{3795ba6c-bb70-4d36-8d46-fa6431157992}">
       <Declaration><![CDATA[(* This method returns the test at the n'th position, ranging from 1.. NumberOfTests *)
 METHOD INTERNAL GetTestByPosition : FB_Test
@@ -3774,7 +3807,8 @@ END_FOR]]></ST>
     <Method Name="SetHasStartedRunning" Id="{ec167018-f922-4541-86e8-8b70c1684943}">
       <Declaration><![CDATA[METHOD INTERNAL SetHasStartedRunning]]></Declaration>
       <Implementation>
-        <ST><![CDATA[HasStartedRunning := TRUE;]]></ST>
+        <ST><![CDATA[StartedAt := F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter);
+]]></ST>
       </Implementation>
     </Method>
     <Method Name="SetTestFailed" Id="{79b1664f-2570-4cef-bd6e-d7307d9a7818}">
@@ -3807,6 +3841,7 @@ END_FOR]]></ST>
 METHOD INTERNAL SetTestFinished : BOOL;
 VAR_INPUT
     TestName : Tc2_System.T_MaxString;
+    FinishedAt : LWORD;
 END_VAR
 VAR
     IteratorCounter : UINT;
@@ -3817,7 +3852,7 @@ END_VAR]]></Declaration>
 NumberOfTestsToAnalyse := GetNumberOfTestsToAnalyse();
 FOR IteratorCounter := 1 TO NumberOfTestsToAnalyse BY 1 DO
     IF Tests[IteratorCounter].GetName() = TestName THEN
-        Tests[IteratorCounter].SetFinished();
+        Tests[IteratorCounter].SetFinished(FinishedAt := FinishedAt);
         SetTestFinished := TRUE;
         RETURN;
     END_IF
@@ -3825,5 +3860,11 @@ END_FOR
 SetTestFinished := FALSE;]]></ST>
       </Implementation>
     </Method>
+    <Method Name="UpdateDuration" Id="{46f255fd-7bfb-4ea3-b0bd-c2a60237aa69}">
+      <Declaration><![CDATA[METHOD INTERNAL UpdateDuration]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[Duration := Duration + LWORD_TO_LREAL(F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter) - StartedAt) * GVL_TcUnit.HundredNanosecondToSecond; // seconds]]></ST>
+      </Implementation>
+    </Method>
   </POU>
 </TcPlcObject>
\ No newline at end of file
diff --git a/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU b/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU
index 80e1f4d..23ff02c 100644
--- a/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU
@@ -103,6 +103,7 @@ IF PublishTrigger.Q THEN
     Xml.NewParameter('disabled', '');
     Xml.NewParameter('failures', UINT_TO_STRING(UnitTestResults.NumberOfFailedTestCases));
     Xml.NewParameter('tests', UINT_TO_STRING(UnitTestResults.NumberOfSuccessfulTestCases));
+    Xml.NewParameter('time', LREAL_TO_STRING(UnitTestResults.Duration));
 
     FOR CurrentSuiteNumber := 1 TO UnitTestResults.NumberOfTestSuites BY 1 DO 
         (* <testsuite> *)
@@ -111,12 +112,14 @@ IF PublishTrigger.Q THEN
         Xml.NewParameter('name', UnitTestResults.TestSuiteResults[CurrentSuiteNumber].name);
         Xml.NewParameter('tests', UINT_TO_STRING(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].NumberOfTests));        
         Xml.NewParameter('failures', UINT_TO_STRING(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].NumberOfFailedTests));
-
+        Xml.NewParameter('time', LREAL_TO_STRING(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].Duration));
+        
         FOR CurrentTestCount := 1 TO UnitTestResults.TestSuiteResults[CurrentSuiteNumber].NumberOfTests BY 1 DO
             (* <testcase> *)
             Xml.NewTag('testcase');
             Xml.NewParameter('name', UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].TestName);
             Xml.NewParameter('classname', UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].TestClassName);
+            Xml.NewParameter('time', LREAL_TO_STRING(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].Duration));
 
             IF UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].TestIsFailed THEN
                 Xml.NewParameter('status', TEST_STATUS_FAIL);
diff --git a/TcUnit/TcUnit/POUs/Functions/F_GetCpuCounterAs64bit.TcPOU b/TcUnit/TcUnit/POUs/Functions/F_GetCpuCounterAs64bit.TcPOU
new file mode 100644
index 0000000..002f022
--- /dev/null
+++ b/TcUnit/TcUnit/POUs/Functions/F_GetCpuCounterAs64bit.TcPOU
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TcPlcObject Version="1.1.0.1" ProductVersion="3.1.4024.11">
+  <POU Name="F_GetCpuCounterAs64bit" Id="{d6ab9606-ef97-4c6c-91e0-367b300d1b7f}" SpecialFunc="None">
+    <Declaration><![CDATA[(* Calls the passed GETCPUCOUNTER function block and
+   converts the output of the GETCPUCOUNTER function block from 2x32bit variables to a 
+   single 64bit variable
+*)
+FUNCTION F_GetCpuCounterAs64bit : LWORD
+VAR_IN_OUT CONSTANT
+    CpuCounter : Tc2_System.GETCPUCOUNTER;
+END_VAR
+]]></Declaration>
+    <Implementation>
+      <ST><![CDATA[cpuCounter();
+F_GetCpuCounterAs64bit := SHL(32, DWORD_TO_LWORD(cpuCounter.cpuCntHiDW)) + DWORD_TO_LWORD(cpuCounter.cpuCntLoDW);]]></ST>
+    </Implementation>
+  </POU>
+</TcPlcObject>
\ No newline at end of file
diff --git a/TcUnit/TcUnit/POUs/Functions/TEST.TcPOU b/TcUnit/TcUnit/POUs/Functions/TEST.TcPOU
index ada271b..ce1fc23 100644
--- a/TcUnit/TcUnit/POUs/Functions/TEST.TcPOU
+++ b/TcUnit/TcUnit/POUs/Functions/TEST.TcPOU
@@ -8,6 +8,7 @@ VAR_INPUT
 END_VAR
 VAR
     CounterTestSuiteAddress : UINT;
+    Test : REFERENCE TO FB_Test;
 END_VAR]]></Declaration>
     <Implementation>
       <ST><![CDATA[TestName := F_LTrim(in := F_RTrim(in := TestName));
@@ -23,8 +24,11 @@ GVL_TcUnit.CurrentTestNameBeingCalled := TestName;
 FOR CounterTestSuiteAddress := 1 TO GVL_TcUnit.NumberOfInitializedTestSuites BY 1 DO
     (* Look for the test suite by comparing to the one that is currently running *)
     IF GVL_TcUnit.TestSuiteAddresses[CounterTestSuiteAddress] = GVL_TcUnit.CurrentTestSuiteBeingCalled THEN
-        GVL_TcUnit.TestSuiteAddresses[CounterTestSuiteAddress]^.AddTest(TestName := TestName, IsTestOrdered := FALSE);
+        Test REF= GVL_TcUnit.TestSuiteAddresses[CounterTestSuiteAddress]^.AddTest(TestName := TestName, IsTestOrdered := FALSE);
         GVL_TcUnit.CurrentTestIsFinished := GVL_TcUnit.TestSuiteAddresses[CounterTestSuiteAddress]^.IsTestFinished(TestName := TestName);
+        IF __ISVALIDREF(Test) THEN
+          Test.SetStartedAtIfNotSet(Timestamp := F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter));
+        END_IF
         RETURN;
     END_IF
 END_FOR]]></ST>
diff --git a/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED.TcPOU b/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED.TcPOU
index 631c4b3..d4c5245 100644
--- a/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED.TcPOU
+++ b/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED.TcPOU
@@ -1,14 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
-<TcPlcObject Version="1.1.0.1" ProductVersion="3.1.4022.18">
+<TcPlcObject Version="1.1.0.1" ProductVersion="3.1.4024.11">
   <POU Name="TEST_FINISHED" Id="{9922b45b-fca5-4323-be8f-93710371a816}" SpecialFunc="None">
     <Declaration><![CDATA[(* Sets the currently running test as finished *)
 FUNCTION TEST_FINISHED : BOOL
 VAR
     TestName : Tc2_System.T_MaxString;
     Counter : UINT := 0;
+    FinishedAt : LWORD;
 END_VAR]]></Declaration>
     <Implementation>
-      <ST><![CDATA[// Grab the currently running test name
+      <ST><![CDATA[// Get the timestamp directly when the test has finished
+FinishedAt := F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter);
+
+// Grab the currently running test name
 TestName := GVL_TcUnit.CurrentTestNameBeingCalled;
 
 TEST_FINISHED := FALSE;
@@ -18,7 +22,7 @@ TEST_FINISHED := FALSE;
 *)
 FOR Counter := 1 TO GVL_TcUnit.NumberOfInitializedTestSuites BY 1 DO
     IF GVL_TcUnit.TestSuiteAddresses[Counter] = GVL_TcUnit.CurrentTestSuiteBeingCalled THEN
-        GVL_TcUnit.TestSuiteAddresses[Counter]^.SetTestFinished(TestName := GVL_TcUnit.CurrentTestNameBeingCalled);
+        GVL_TcUnit.TestSuiteAddresses[Counter]^.SetTestFinished(TestName := GVL_TcUnit.CurrentTestNameBeingCalled, FinishedAt := FinishedAt);
         GVL_TcUnit.TestSuiteAddresses[Counter]^.CalculateAndSetNumberOfAssertsForTest(TestName := GVL_TcUnit.CurrentTestNameBeingCalled);
         GVL_TcUnit.CurrentTestIsFinished := TRUE;
         TEST_FINISHED := TRUE;
diff --git a/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED_NAMED.TcPOU b/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED_NAMED.TcPOU
index c3c8e26..9970ef2 100644
--- a/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED_NAMED.TcPOU
+++ b/TcUnit/TcUnit/POUs/Functions/TEST_FINISHED_NAMED.TcPOU
@@ -10,6 +10,7 @@ END_VAR
 VAR
     Counter : UINT := 0;
     FoundTestName : BOOL := FALSE;
+    FinishedAt : LWORD; // cpu cycle counter in 100ns precision
 END_VAR
 VAR_STAT
     FailedLookupCounter : UINT := 0;
@@ -20,6 +21,7 @@ VAR CONSTANT
 END_VAR]]></Declaration>
     <Implementation>
       <ST><![CDATA[TestName := F_LTrim(in := F_RTrim(in := TestName));
+FinishedAt := F_GetCpuCounterAs64bit(GVL_TcUnit.GetCpuCounter);
 
 (* Find the test suite and:
    1. Set the test in that test suite as finished
@@ -27,7 +29,7 @@ END_VAR]]></Declaration>
 *)
 FOR Counter := 1 TO GVL_TcUnit.NumberOfInitializedTestSuites BY 1 DO
     IF GVL_TcUnit.TestSuiteAddresses[Counter] = GVL_TcUnit.CurrentTestSuiteBeingCalled THEN
-        FoundTestName := GVL_TcUnit.TestSuiteAddresses[Counter]^.SetTestFinished(TestName := TestName);
+        FoundTestName := GVL_TcUnit.TestSuiteAddresses[Counter]^.SetTestFinished(TestName := TestName, FinishedAt := FinishedAt);
         IF NOT FoundTestName THEN
             IF FailedLookupCounter < MaxNumberOfNonExistentTestNamesFailedLookups THEN
                 GVL_TcUnit.AdsMessageQueue.WriteLog(MsgCtrlMask := Tc2_System.ADSLOG_MSGTYPE_ERROR,
@@ -51,4 +53,4 @@ FOR Counter := 1 TO GVL_TcUnit.NumberOfInitializedTestSuites BY 1 DO
 END_FOR]]></ST>
     </Implementation>
   </POU>
-</TcPlcObject>
\ No newline at end of file
+</TcPlcObject>
diff --git a/TcUnit/TcUnit/TcUnit.plcproj b/TcUnit/TcUnit/TcUnit.plcproj
index c3b39fd..c2a16de 100644
--- a/TcUnit/TcUnit/TcUnit.plcproj
+++ b/TcUnit/TcUnit/TcUnit.plcproj
@@ -32,7 +32,7 @@ Documentation and examples are available at www.tcunit.org</Description>
     </SelectedLibraryCategories>
     <Company>www.tcunit.org</Company>
     <Author>Jakob Sagatowski and contributors</Author>
-    <ProjectVersion>1.2.1.0</ProjectVersion>
+    <ProjectVersion>1.2.2.0</ProjectVersion>
     <!--    <OutputType>Exe</OutputType>
     <RootNamespace>MyApplication</RootNamespace>
     <AssemblyName>MyApplication</AssemblyName>-->
@@ -148,6 +148,9 @@ Documentation and examples are available at www.tcunit.org</Description>
     <Compile Include="POUs\Functions\F_AssertionTypeToString.TcPOU">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="POUs\Functions\F_GetCpuCounterAs64bit.TcPOU">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="POUs\Functions\F_GetTestSuiteNameFromTestInstancePath.TcPOU">
       <SubType>Code</SubType>
     </Compile>
diff --git a/TcUnit/TcUnit/Version/Global_Version.TcGVL b/TcUnit/TcUnit/Version/Global_Version.TcGVL
index 4d7d59f..b9e265d 100644
--- a/TcUnit/TcUnit/Version/Global_Version.TcGVL
+++ b/TcUnit/TcUnit/Version/Global_Version.TcGVL
@@ -7,7 +7,7 @@
 // This function has been automatically generated from the project information.
 VAR_GLOBAL CONSTANT
 	{attribute 'const_non_replaced'}
-	stLibVersion_TcUnit : ST_LibVersion := (iMajor := 1, iMinor := 2, iBuild := 1, iRevision := 0, sVersion := '1.2.1.0');
+	stLibVersion_TcUnit : ST_LibVersion := (iMajor := 1, iMinor := 2, iBuild := 2, iRevision := 0, sVersion := '1.2.2.0');
 END_VAR
 ]]></Declaration>
   </GVL>