From c7c856302f6ada9675c6a8e8e84b95d0a0ac8f36 Mon Sep 17 00:00:00 2001
From: Stefan Besler <stefan@besler.me>
Date: Sat, 18 Nov 2023 17:40:24 +0100
Subject: [PATCH] feat(xUnitXmlPublisher): Include assertion message in test
 output

---
 TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT    |   1 +
 .../TcUnit/ITFs/I_AssertMessageFormatter.TcIO |   2 +-
 .../POUs/FB_AdsAssertMessageFormatter.TcPOU   |   7 +-
 TcUnit/TcUnit/POUs/FB_Test.TcPOU              |  19 +
 TcUnit/TcUnit/POUs/FB_TestResults.TcPOU       |   4 +
 TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU         | 471 +++++++++++++-----
 TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU |  24 +-
 TcUnit/TcUnit/TcUnit.plcproj                  |   2 +-
 TcUnit/TcUnit/Version/Global_Version.TcGVL    |   2 +-
 9 files changed, 396 insertions(+), 136 deletions(-)

diff --git a/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT b/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT
index 2d77c16..d0c58e2 100644
--- a/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT
+++ b/TcUnit/TcUnit/DUTs/ST_TestCaseResult.TcDUT
@@ -8,6 +8,7 @@ STRUCT
     TestIsFailed : BOOL;
     TestIsSkipped : BOOL;
     FailureMessage : T_MaxString;
+    FailureAssertion : Tc2_System.T_MaxString;
     FailureType : E_AssertionType;
     NumberOfAsserts : UINT;
     Duration : LREAL; // in seconds
diff --git a/TcUnit/TcUnit/ITFs/I_AssertMessageFormatter.TcIO b/TcUnit/TcUnit/ITFs/I_AssertMessageFormatter.TcIO
index 67bfe3e..59cae67 100644
--- a/TcUnit/TcUnit/ITFs/I_AssertMessageFormatter.TcIO
+++ b/TcUnit/TcUnit/ITFs/I_AssertMessageFormatter.TcIO
@@ -4,7 +4,7 @@
     <Declaration><![CDATA[INTERFACE I_AssertMessageFormatter
 ]]></Declaration>
     <Method Name="LogAssertFailure" Id="{35efab01-6ac8-46a5-a5e1-adb4f1f5f9b2}">
-      <Declaration><![CDATA[METHOD LogAssertFailure
+      <Declaration><![CDATA[METHOD LogAssertFailure : Tc2_System.T_MaxString
 VAR_INPUT
     Expected : T_MaxString;
     Actual : T_MaxString;
diff --git a/TcUnit/TcUnit/POUs/FB_AdsAssertMessageFormatter.TcPOU b/TcUnit/TcUnit/POUs/FB_AdsAssertMessageFormatter.TcPOU
index 1b441d6..86402e1 100644
--- a/TcUnit/TcUnit/POUs/FB_AdsAssertMessageFormatter.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_AdsAssertMessageFormatter.TcPOU
@@ -11,7 +11,7 @@ FUNCTION_BLOCK FB_AdsAssertMessageFormatter IMPLEMENTS I_AssertMessageFormatter]
       <ST><![CDATA[]]></ST>
     </Implementation>
     <Method Name="LogAssertFailure" Id="{48cbc6b0-5380-44b8-a045-57b6ad9f189d}">
-      <Declaration><![CDATA[METHOD PUBLIC LogAssertFailure
+      <Declaration><![CDATA[METHOD PUBLIC LogAssertFailure : Tc2_System.T_MaxString
 VAR_INPUT
     Expected : T_MaxString;
     Actual : T_MaxString;
@@ -24,7 +24,7 @@ VAR
     TestInstancePathFinal : T_MaxString;
     ReturnValue : DINT;
     TestInstancePathProcessed : T_MaxString;
-    MessageProcessed : T_MaxString;
+    MessageProcessed : Tc2_System.T_MaxString;    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[TestInstancePathCleaned := F_RemoveInstancePathAndProjectNameFromTestInstancePath(TestInstancePath);
@@ -34,10 +34,13 @@ TestInstancePathFinal := CONCAT(STR1 := TestInstancePathFinal, STR2 := '$'');
 IF LEN(STR := Expected) > 0 THEN
     TestInstancePathFinal := CONCAT(STR1 := TestInstancePathFinal, STR2 := ', EXP: ');
     TestInstancePathFinal := CONCAT(STR1 := TestInstancePathFinal, STR2 := Expected);
+    LogAssertFailure := Tc2_Standard.CONCAT('EXP: ', Expected);
 END_IF
 IF LEN(STR := Actual) > 0 THEN
     TestInstancePathFinal := CONCAT(STR1 := TestInstancePathFinal, STR2 := ', ACT: ');
     TestInstancePathFinal := CONCAT(STR1 := TestInstancePathFinal, STR2 := Actual);
+    LogAssertFailure := Tc2_Standard.CONCAT(LogAssertFailure, ', ACT: ');     
+    LogAssertFailure := Tc2_Standard.CONCAT(LogAssertFailure, Actual);  
 END_IF
 IF LEN(STR := Message) > 0 THEN
     TestInstancePathFinal := CONCAT(STR1 := TestInstancePathFinal, STR2 := ', MSG: %s');
diff --git a/TcUnit/TcUnit/POUs/FB_Test.TcPOU b/TcUnit/TcUnit/POUs/FB_Test.TcPOU
index bffa9f3..b7efc23 100644
--- a/TcUnit/TcUnit/POUs/FB_Test.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_Test.TcPOU
@@ -19,6 +19,7 @@ VAR
     (* Failure parameters. If TestIsFailed is TRUE, the other parameters will hold values as well *)
     TestIsFailed : BOOL; // Indication of whether this test has at least one failed assert
     AssertionMessage : T_MaxString; // Assertion message for the first assertion in this test
+    AssertionFailure : Tc2_System.T_MaxString; // Assertion failure 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
@@ -27,6 +28,12 @@ END_VAR]]></Declaration>
     <Implementation>
       <ST><![CDATA[]]></ST>
     </Implementation>
+    <Method Name="GetAssertionFailure" Id="{fca1dda8-8d75-01ba-01c5-90dc1cec56b1}">
+      <Declaration><![CDATA[METHOD INTERNAL GetAssertionFailure : Tc2_System.T_MaxString]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[GetAssertionFailure := AssertionFailure;]]></ST>
+      </Implementation>
+    </Method>
     <Method Name="GetAssertionMessage" Id="{273c4e89-faee-43b5-803d-428cdf75ac48}">
       <Declaration><![CDATA[METHOD INTERNAL GetAssertionMessage : T_MaxString]]></Declaration>
       <Implementation>
@@ -82,6 +89,18 @@ METHOD INTERNAL GetTestOrder : UINT(0..GVL_Param_TcUnit.MaxNumberOfTestsForEachT
         <ST><![CDATA[IsSkipped := TestIsSkipped;]]></ST>
       </Implementation>
     </Method>
+    <Method Name="SetAssertionFailure" Id="{0c7899f5-2be3-0920-30bd-e2b4051f82f8}">
+      <Declaration><![CDATA[(* Sets the assertion failure. If one already exists, it's not overwritten as we keep the first assertion in the test *)
+METHOD INTERNAL SetAssertionFailure
+VAR_INPUT
+    AssertFailure : Tc2_System.T_MaxString;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[IF Tc2_Standard.LEN(STR := AssertionFailure) = 0 THEN
+    AssertionFailure := AssertFailure;
+END_IF]]></ST>
+      </Implementation>
+    </Method>
     <Method Name="SetAssertionMessage" Id="{05091715-93d7-47f7-9b6c-cb2511f88eb7}">
       <Declaration><![CDATA[(* Sets the assertion message. If one already exists, it's not overwritten as we keep the first assertion in the test *)
 METHOD INTERNAL SetAssertionMessage
diff --git a/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU b/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU
index 801e587..cba4f43 100644
--- a/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_TestResults.TcPOU
@@ -74,6 +74,10 @@ IF StoringTestSuiteResultNumber <= GVL_TcUnit.NumberOfInitializedTestSuites AND
             (* Store the (first failed) assertion message *)
             TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].FailureMessage :=
                 TestToBeStored.GetAssertionMessage();
+                
+            (* Store the (first failed) assertion failure *)
+            TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].FailureAssertion :=
+                TestToBeStored.GetAssertionFailure();
 
             (* Store the (first failed) assertion type *)
             TestSuiteResults.TestSuiteResults[StoringTestSuiteResultNumber].TestCaseResults[TestsInTestSuiteCounter].FailureType :=
diff --git a/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU b/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU
index 6474d45..f356ac7 100644
--- a/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_TestSuite.TcPOU
@@ -215,6 +215,8 @@ VAR
     ActualArrayIndex : ARRAY[1..2] OF DINT; // Array of current Actual array indexes when looping through arrays
     Expected : LREAL; // Single expected value
     Actual : LREAL; // Single actual value
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -282,8 +284,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds[1
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -330,10 +331,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := LREAL_TO_STRING(Actual));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -369,6 +374,8 @@ VAR
     ActualArrayIndex : ARRAY[1..2] OF DINT; // Array of current Actual array indexes when looping through arrays
     Expected : REAL; // Single expected value
     Actual : REAL; // Single actual value
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -436,8 +443,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds[1
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_REAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -483,11 +489,15 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
         ActualString := CONCAT(STR1 := ActualString, STR2 := REAL_TO_STRING(Actual));
     END_IF
-
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -523,6 +533,8 @@ VAR
     ActualArrayIndex : ARRAY[1..3] OF DINT; // Array of current Actual array indexes when looping through arrays
     Expected : LREAL; // Single expected value
     Actual : LREAL; // Single actual value
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -601,8 +613,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds[1
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array3D_LREAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -665,10 +676,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := LREAL_TO_STRING(Actual));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -707,6 +722,8 @@ VAR
     ExpectedValueString : T_MaxString;
     ActualValueString : T_MaxString;
     FormatString : FB_FormatString; // String formatter for output messages
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -785,8 +802,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds[1
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array3D_REAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -849,10 +865,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := REAL_TO_STRING(Actual));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -880,6 +900,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -918,8 +940,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_BOOL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -939,10 +960,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := BOOL_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -972,6 +997,8 @@ VAR
     ActualByteString : STRING;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1011,8 +1038,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_BYTE,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1040,10 +1066,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := ActualByteString);
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1071,6 +1101,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1109,8 +1141,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_DINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1130,10 +1161,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1163,6 +1198,8 @@ VAR
     ActualDWordString : STRING;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1201,8 +1238,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_DWORD,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1230,10 +1266,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := ActualDWordString);
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1261,6 +1301,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1299,8 +1341,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_INT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1320,10 +1361,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := INT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1351,6 +1396,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1389,8 +1436,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_LINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1410,10 +1456,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := LINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1442,6 +1492,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1480,8 +1532,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_LREAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1501,10 +1552,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := LREAL_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1534,6 +1589,8 @@ VAR
     ActualLWordString : STRING;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1572,8 +1629,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_LWORD,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1601,10 +1657,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := ActualLWordString);
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1633,6 +1693,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1671,8 +1733,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_REAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1692,10 +1753,13 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := REAL_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1723,6 +1787,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1761,8 +1827,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_SINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1782,10 +1847,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := SINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1813,6 +1882,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1851,8 +1922,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_UDINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
     
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1869,14 +1939,17 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := 'ARRAY[';
         ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
         ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
-        ActualString := 
-CONCAT(STR1 := ActualString, STR2 := UDINT_TO_STRING(Actuals[ActualsIndex]));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := UDINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1904,6 +1977,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -1942,8 +2017,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_UINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -1963,10 +2037,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := UINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -1994,6 +2072,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2032,8 +2112,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_ULINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -2053,10 +2132,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := ULINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2084,6 +2167,8 @@ VAR
     SizeOfActuals : DINT;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2122,8 +2207,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_USINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -2143,10 +2227,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := USINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2176,6 +2264,8 @@ VAR
     ActualDWordString : STRING;
     ExpectedsIndex : DINT;
     ActualsIndex : DINT;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2214,8 +2304,7 @@ AssertArrayResults.ReportResult(ExpectedsSize := DINT_TO_UDINT(SizeOfExpecteds),
                                 AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND NOT Equals THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_Array_WORD,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
     IF NOT SizeEquals THEN
         Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
@@ -2243,10 +2332,14 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := ActualDWordString);
     END_IF
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2319,6 +2412,9 @@ VAR
     DataSizeNotEquals : BOOL; // The data size of the two ANY input parameters are not equal
     DataContentNotEquals : BOOL; // The data content of the two ANY input parameters are not equal
     IteratorCounter : DINT;
+    
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2607,13 +2703,16 @@ AssertResults.ReportResult(ExpectedSize := DINT_TO_UDINT(Expected.diSize),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND (DataTypesNotEquals OR DataSizeNotEquals OR DataContentNotEquals) THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_ANY,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedDataString,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ExpectedDataString,
                                             Actual := ActualDataString,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2630,6 +2729,8 @@ END_VAR
 VAR
     AlreadyReported : BOOL;
     TestInstancePath : T_MaxString;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2649,13 +2750,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_BOOL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := BOOL_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := BOOL_TO_STRING(Expected),
                                             Actual := BOOL_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2672,6 +2776,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2691,10 +2797,9 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_BYTE,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := CONCAT(
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := Tc2_Standard.CONCAT(
                                                        STR1 := '0x',
                                                        STR2 := BYTE_TO_HEXSTR(in := Expected,
                                                                                             iPrecision := 2,
@@ -2706,6 +2811,10 @@ IF NOT AlreadyReported AND Expected <> Actual THEN
                                                                                             bLoCase := FALSE)),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2722,6 +2831,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2741,13 +2852,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_DATE,
-                  AssertionMessage := Message);
-
-    AssertMessageFormatter.LogAssertFailure(Expected := DATE_TO_STRING(Expected),
+    TestMessage := Message;
+    
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := DATE_TO_STRING(Expected),
                                             Actual := DATE_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2764,6 +2878,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2783,13 +2899,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_DATE_AND_TIME,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := DT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := DT_TO_STRING(Expected),
                                             Actual := DT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2806,6 +2925,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2825,13 +2946,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_DINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := DINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := DINT_TO_STRING(Expected),
                                             Actual := DINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2848,6 +2972,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2867,10 +2993,9 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_DWORD,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := CONCAT(
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := Tc2_Standard.CONCAT(
                                                             STR1 := '0x',
                                                             STR2 := DWORD_TO_HEXSTR(in := Expected,
                                                                                                   iPrecision := 8,
@@ -2882,6 +3007,10 @@ IF NOT AlreadyReported AND Expected <> Actual THEN
                                                                                                  bLoCase := FALSE)),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2898,6 +3027,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2917,13 +3048,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_INT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := INT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := INT_TO_STRING(Expected),
                                             Actual := INT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2940,6 +3074,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -2959,13 +3095,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_LINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := LINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := LINT_TO_STRING(Expected),
                                             Actual := LINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -2983,6 +3122,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3002,13 +3143,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND ABS(Expected - Actual) > Delta THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_LREAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := LREAL_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := LREAL_TO_STRING(Expected),
                                             Actual := LREAL_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3025,6 +3169,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3044,13 +3190,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_LTIME,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := LTIME_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := LTIME_TO_STRING(Expected),
                                             Actual := LTIME_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3067,6 +3216,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3086,10 +3237,9 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_LWORD,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := CONCAT(
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := Tc2_Standard.CONCAT(
                                                             STR1 := '0x',
                                                             STR2 := LWORD_TO_HEXSTR(in := Expected,
                                                                                                   iPrecision := 16,
@@ -3101,6 +3251,10 @@ IF NOT AlreadyReported AND Expected <> Actual THEN
                                                                                                   bLoCase := FALSE)),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3118,6 +3272,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3137,13 +3293,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND ABS(Expected - Actual) > Delta THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_REAL,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := REAL_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := REAL_TO_STRING(Expected),
                                             Actual := REAL_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3160,6 +3319,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3179,13 +3340,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_SINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := SINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := SINT_TO_STRING(Expected),
                                             Actual := SINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3202,6 +3366,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3221,13 +3387,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND (LEN(STR := Expected) <> LEN(STR := Actual) OR (Expected <> Actual)) THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_STRING,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := Expected,
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := Expected,
                                             Actual := Actual,
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3244,6 +3413,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3263,13 +3434,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_TIME,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := TIME_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := TIME_TO_STRING(Expected),
                                             Actual := TIME_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3286,6 +3460,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3305,13 +3481,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_TIME_OF_DAY,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := TOD_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := TOD_TO_STRING(Expected),
                                             Actual := TOD_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3328,6 +3507,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3347,13 +3528,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_UDINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := UDINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := UDINT_TO_STRING(Expected),
                                             Actual := UDINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3370,6 +3554,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3389,13 +3575,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_UINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := UINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := UINT_TO_STRING(Expected),
                                             Actual := UINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3412,6 +3601,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3431,13 +3622,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_ULINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := ULINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := ULINT_TO_STRING(Expected),
                                             Actual := ULINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3454,6 +3648,8 @@ END_VAR
 VAR
     AlreadyReported : BOOL;
     TestInstancePath : T_MaxString;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3473,13 +3669,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_USINT,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := USINT_TO_STRING(Expected),
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := USINT_TO_STRING(Expected),
                                             Actual := USINT_TO_STRING(Actual),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3496,6 +3695,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3515,10 +3716,9 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND Expected <> Actual THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_WORD,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := CONCAT(
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := Tc2_Standard.CONCAT(
                                                             STR1 := '0x',
                                                             STR2 := WORD_TO_HEXSTR(in := Expected,
                                                                                                  iPrecision := 4,
@@ -3530,6 +3730,10 @@ IF NOT AlreadyReported AND Expected <> Actual THEN
                                                                                                  bLoCase := FALSE)),
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3546,6 +3750,8 @@ END_VAR
 VAR
     TestInstancePath : T_MaxString;
     AlreadyReported : BOOL;
+    TestMessage : Tc2_System.T_MaxString; // Holds the actual message of the test
+    TestFailure : Tc2_System.T_MaxString; // Holds the failure message of the test    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[IF GVL_TcUnit.IgnoreCurrentTest OR GVL_TcUnit.CurrentTestIsFinished THEN
@@ -3565,13 +3771,16 @@ AssertResults.ReportResult(ExpectedSize := SIZEOF(Expected),
                            AlreadyReported => AlreadyReported);
 
 IF NOT AlreadyReported AND (WLEN(STR := Expected) <> WLEN(STR := Actual) OR (Expected <> Actual)) THEN
-    SetTestFailed(AssertionType := E_AssertionType.Type_WSTRING,
-                  AssertionMessage := Message);
+    TestMessage := Message;
 
-    AssertMessageFormatter.LogAssertFailure(Expected := 'Not possible to print EXP unicode WSTRING value',
+    TestFailure := AssertMessageFormatter.LogAssertFailure(Expected := 'Not possible to print EXP unicode WSTRING value',
                                             Actual := 'Not possible to print ACT unicode WSTRING value',
                                             Message := Message,
                                             TestInstancePath := TestInstancePath);
+                                            
+    SetTestFailed(AssertionType := E_AssertionType.Type_Array2D_LREAL,
+                  AssertionMessage := TestMessage,
+                  AssertionFailure := TestFailure);                                               
 END_IF]]></ST>
       </Implementation>
     </Method>
@@ -3838,6 +4047,7 @@ END_IF]]></ST>
 VAR_INPUT
     AssertionType : E_AssertionType;
     AssertionMessage : T_MaxString;
+    AssertionFailure : Tc2_System.T_MaxString;	
 END_VAR
 VAR
     IteratorCounter : UINT;
@@ -3852,6 +4062,7 @@ FOR IteratorCounter := 1 TO NumberOfTestsToAnalyse BY 1 DO
         Tests[IteratorCounter].SetFailed();
         Tests[IteratorCounter].SetAssertionType(AssertType := AssertionType);
         Tests[IteratorCounter].SetAssertionMessage(AssertMessage := AssertionMessage);
+        Tests[IteratorCounter].SetAssertionFailure(AssertFailure := AssertionFailure);		
     END_IF
 END_FOR]]></ST>
       </Implementation>
diff --git a/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU b/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU
index 500bc11..bb4b56f 100644
--- a/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_xUnitXmlPublisher.TcPOU
@@ -82,11 +82,17 @@ VAR
     UnitTestResults : REFERENCE TO ST_TestSuiteResults;
     CurrentSuiteNumber : UINT;
     CurrentTestCount : UINT;
+    AdjustAssertFailureMessageToMax253CharLength : FB_AdjustAssertFailureMessageToMax253CharLength;    
+    message : Tc2_System.T_MaxString;
+    FailureMessageLen : INT;
+    AssertionMessageLen : INT;
 END_VAR
 VAR CONSTANT
     TEST_STATUS_SKIP : STRING := 'SKIP';
     TEST_STATUS_PASS : STRING := 'PASS';
     TEST_STATUS_FAIL : STRING := 'FAIL';
+    MSG_FMT_STRING_MAX_NUMBER_OF_CHARACTERS : INT := 253;
+    MSG_TOO_LONG : STRING := '...';    
 END_VAR]]></Declaration>
       <Implementation>
         <ST><![CDATA[UnitTestResults REF=TestResults.GetTestSuiteResults();
@@ -134,8 +140,24 @@ IF PublishTrigger.Q THEN
                 (* In case of fail 
                     <failure message="Values differ" type="BYTE" />
                 *)
+                
+                FailureMessageLen := Tc2_Standard.LEN(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureMessage);
+                AssertionMessageLen := Tc2_Standard.LEN(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureAssertion);
+                IF FailureMessageLen = 0
+                THEN
+                  message := UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureAssertion;
+                ELSE
+                  message := CONCAT(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureMessage, CONCAT('; ', UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureAssertion));
+
+                  IF Tc2_Standard.LEN(message) > MSG_FMT_STRING_MAX_NUMBER_OF_CHARACTERS
+                  THEN
+                    message := Tc2_Standard.LEFT(STR := message, SIZE := (MSG_FMT_STRING_MAX_NUMBER_OF_CHARACTERS - Tc2_Standard.LEN(STR := MSG_TOO_LONG)));
+                    message := Tc2_Standard.CONCAT(STR1 := message, STR2 := MSG_TOO_LONG);
+                  END_IF
+                END_IF
+                
                 Xml.NewTag('failure');
-                Xml.NewParameter('message', UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureMessage);
+                Xml.NewParameter('message', message);
                 Xml.NewParameter('type', F_AssertionTypeToString(UnitTestResults.TestSuiteResults[CurrentSuiteNumber].TestCaseResults[CurrentTestCount].FailureType));       
                 (* Close failure tag *)
                 Xml.CloseTag();
diff --git a/TcUnit/TcUnit/TcUnit.plcproj b/TcUnit/TcUnit/TcUnit.plcproj
index 6fd1202..fc33fd3 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>
     <WriteProductVersion>false</WriteProductVersion>
     <!--    <OutputType>Exe</OutputType>
     <RootNamespace>MyApplication</RootNamespace>
diff --git a/TcUnit/TcUnit/Version/Global_Version.TcGVL b/TcUnit/TcUnit/Version/Global_Version.TcGVL
index c1ae8cf..922b871 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, nFlags := 0, sVersion := '1.2.2.0');
 END_VAR
 ]]></Declaration>
   </GVL>