From 9b62e218868b809df745d3e53ef49be241f39f95 Mon Sep 17 00:00:00 2001
From: Jakob Sagatowski <jakob.sagatowski@outlook.com>
Date: Sun, 9 Dec 2018 17:22:19 +0100
Subject: [PATCH] Solved issue #2 "Add functionality to make it possible to
 ASSERT arrays".

---
 TcUnit/TcUnit/POUs/FB_Assert.TcPOU | 709 +++++++++++++++++++++++++++++
 1 file changed, 709 insertions(+)

diff --git a/TcUnit/TcUnit/POUs/FB_Assert.TcPOU b/TcUnit/TcUnit/POUs/FB_Assert.TcPOU
index b27f155..62a024e 100644
--- a/TcUnit/TcUnit/POUs/FB_Assert.TcPOU
+++ b/TcUnit/TcUnit/POUs/FB_Assert.TcPOU
@@ -542,6 +542,607 @@ IF NOT AlreadyReported AND NOT Equals THEN
         ActualString := CONCAT(STR1 := ActualString, STR2 := LINT_TO_STRING(Actuals[ActualsIndex]));
     END_IF
 
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_LWORD" Id="{7bc0c786-fccc-46e3-b38f-2013c44bfcb0}">
+      <Declaration><![CDATA[(*
+    Asserts that two LWORD arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_LWORD
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF LWORD; // LWORD array with expected values
+    Actuals : ARRAY[*] OF LWORD; // LWORD array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedDWordString : STRING;
+    ActualDWordString : STRING;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedDWordString := Tc2_Standard.CONCAT(STR1 := '0x',
+                                                  STR2 := Tc2_Utilities.LWORD_TO_HEXSTR(in := Expecteds[ExpectedsIndex],
+                                                                                        iPrecision := 16,
+                                                                                        bLoCase := FALSE));
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := ExpectedDWordString);
+
+        ActualDWordString := Tc2_Standard.CONCAT(STR1 := '0x',
+                                                STR2 := Tc2_Utilities.LWORD_TO_HEXSTR(in := Actuals[ActualsIndex],
+                                                                                      iPrecision := 16,
+                                                                                      bLoCase := FALSE));
+        ActualString := 'ARRAY[';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
+        ActualString := CONCAT(STR1 := ActualString, STR2 := ActualDWordString);
+    END_IF
+
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_SINT" Id="{133c577e-0641-4157-b42b-46dbf29f788e}">
+      <Declaration><![CDATA[(*
+    Asserts that two SINT arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_SINT
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF SINT; // SINT array with expected values
+    Actuals : ARRAY[*] OF SINT; // SINT array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := SINT_TO_STRING(Expecteds[ExpectedsIndex]));
+
+        ActualString := 'ARRAY[';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
+        ActualString := CONCAT(STR1 := ActualString, STR2 := SINT_TO_STRING(Actuals[ActualsIndex]));
+    END_IF
+
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_UDINT" Id="{5f690331-57e2-4ea1-b1d7-ab65b52dc848}">
+      <Declaration><![CDATA[(*
+    Asserts that two UDINT arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_UDINT
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF UDINT; // UDINT array with expected values
+    Actuals : ARRAY[*] OF UDINT; // UDINT array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := UDINT_TO_STRING(Expecteds[ExpectedsIndex]));
+
+        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]));
+    END_IF
+
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_UINT" Id="{358571ac-0a0d-4e71-8097-c7943f718fce}">
+      <Declaration><![CDATA[(*
+    Asserts that two UINT arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_UINT
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF UINT; // UINT array with expected values
+    Actuals : ARRAY[*] OF UINT; // UINT array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := UINT_TO_STRING(Expecteds[ExpectedsIndex]));
+
+        ActualString := 'ARRAY[';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
+        ActualString := CONCAT(STR1 := ActualString, STR2 := UINT_TO_STRING(Actuals[ActualsIndex]));
+    END_IF
+
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_ULINT" Id="{916529a0-57b3-4947-a5b8-e7b9ff17f35f}">
+      <Declaration><![CDATA[(*
+    Asserts that two ULINT arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_ULINT
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF ULINT; // ULINT array with expected values
+    Actuals : ARRAY[*] OF ULINT; // ULINT array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := ULINT_TO_STRING(Expecteds[ExpectedsIndex]));
+
+        ActualString := 'ARRAY[';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
+        ActualString := CONCAT(STR1 := ActualString, STR2 := ULINT_TO_STRING(Actuals[ActualsIndex]));
+    END_IF
+
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_USINT" Id="{b3215098-2f26-48bf-a7e4-ee1a0803a968}">
+      <Declaration><![CDATA[(*
+    Asserts that two USINT arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_USINT
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF USINT; // USINT array with expected values
+    Actuals : ARRAY[*] OF USINT; // USINT array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := USINT_TO_STRING(Expecteds[ExpectedsIndex]));
+
+        ActualString := 'ARRAY[';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
+        ActualString := CONCAT(STR1 := ActualString, STR2 := USINT_TO_STRING(Actuals[ActualsIndex]));
+    END_IF
+
+    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
+                                            Actual := ActualString,
+                                            Message := Message,
+                                            TestInstancePath := TestInstancePath);
+END_IF]]></ST>
+      </Implementation>
+    </Method>
+    <Method Name="AssertArrayEquals_WORD" Id="{16eada18-ce2b-459d-a8d9-277e84766935}">
+      <Declaration><![CDATA[(*
+    Asserts that two WORD arrays are equal. If they are not, an assertion error is created.
+*)
+METHOD PUBLIC AssertArrayEquals_WORD
+VAR_IN_OUT
+    Expecteds : ARRAY[*] OF WORD; // WORD array with expected values
+    Actuals : ARRAY[*] OF WORD; // WORD array with actual values
+END_VAR
+VAR_INPUT
+    Message : Tc2_System.T_MaxString; // The identifying message for the assertion error
+END_VAR
+VAR
+    Equals : BOOL := TRUE;
+    SizeEquals : BOOL := TRUE;
+    Index : DINT;
+    ExpectedString : STRING;
+    ActualString : STRING;
+    AlreadyReported : BOOL;
+    TestInstancePath : Tc2_System.T_MaxString;
+    SizeOfExpecteds : DINT;
+    SizeOfActuals : DINT;
+    ExpectedDWordString : STRING;
+    ActualDWordString : STRING;
+    ExpectedsIndex : DINT;
+    ActualsIndex : DINT;
+END_VAR]]></Declaration>
+      <Implementation>
+        <ST><![CDATA[TestInstancePath := AddTestNameToInstancePath(FindTestSuiteInstancePath());
+
+SizeOfExpecteds := ABS(UPPER_BOUND(Expecteds, 1) - LOWER_BOUND(Expecteds, 1)) + 1;
+SizeOfActuals := ABS(UPPER_BOUND(Actuals, 1) - LOWER_BOUND(Actuals, 1)) + 1;
+
+IF SizeOfExpecteds <> SizeOfActuals THEN
+    Equals := FALSE;
+    SizeEquals := FALSE;
+ELSE
+    (* Even though we know that both arrays are equal in size, the two arrays can start at two completely different
+       indexes, which needs to be taken into account for. *)
+    ExpectedsIndex := LOWER_BOUND(Expecteds, 1); // The start position for the expecteds
+    ActualsIndex := LOWER_BOUND(Actuals, 1); // The start position for the actuals
+    FOR Index := 1 TO SizeOfExpecteds BY 1 DO
+        IF Expecteds[ExpectedsIndex] <> Actuals[ActualsIndex] THEN
+            Equals := FALSE;
+            EXIT;
+		END_IF
+        ExpectedsIndex := ExpectedsIndex + 1;
+        ActualsIndex := ActualsIndex + 1;
+	END_FOR
+END_IF
+
+AssertResults.ReportResult(Expected := Expecteds,
+                           Actual := Actuals,
+                           Message := Message,
+                           TestInstancePath := TestInstancePath,
+                           AlreadyReported => AlreadyReported);
+
+IF NOT AlreadyReported AND NOT Equals THEN
+    SetTestFailed();
+    
+    IF NOT SizeEquals THEN
+        Message := CONCAT(STR1 := Message, STR2 := ', size of arrays not matching.');
+        ExpectedString := 'SIZE = ';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(SizeOfExpecteds));
+        ActualString := 'SIZE = ';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(SizeOfActuals));
+    ELSE
+        ExpectedDWordString := Tc2_Standard.CONCAT(STR1 := '0x',
+                                                  STR2 := Tc2_Utilities.WORD_TO_HEXSTR(in := Expecteds[ExpectedsIndex],
+                                                                                       iPrecision := 4,
+                                                                                       bLoCase := FALSE));
+        ExpectedString := 'ARRAY[';
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := DINT_TO_STRING(ExpectedsIndex));
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := '] = ');
+        ExpectedString := CONCAT(STR1 := ExpectedString, STR2 := ExpectedDWordString);
+
+        ActualDWordString := Tc2_Standard.CONCAT(STR1 := '0x',
+                                                STR2 := Tc2_Utilities.WORD_TO_HEXSTR(in := Actuals[ActualsIndex],
+                                                                                     iPrecision := 4,
+                                                                                     bLoCase := FALSE));
+        ActualString := 'ARRAY[';
+        ActualString := CONCAT(STR1 := ActualString, STR2 := DINT_TO_STRING(ActualsIndex));
+        ActualString := CONCAT(STR1 := ActualString, STR2 := '] = ');
+        ActualString := CONCAT(STR1 := ActualString, STR2 := ActualDWordString);
+    END_IF
+
     AssertMessageFormatter.LogAssertFailure(Expected := ExpectedString,
                                             Actual := ActualString,
                                             Message := Message,
@@ -1356,6 +1957,114 @@ END_FOR]]></ST>
       <LineId Id="116" Count="14" />
       <LineId Id="10" Count="0" />
     </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_LWORD">
+      <LineId Id="89" Count="0" />
+      <LineId Id="216" Count="1" />
+      <LineId Id="90" Count="0" />
+      <LineId Id="218" Count="0" />
+      <LineId Id="91" Count="0" />
+      <LineId Id="93" Count="2" />
+      <LineId Id="219" Count="0" />
+      <LineId Id="222" Count="1" />
+      <LineId Id="226" Count="1" />
+      <LineId Id="231" Count="1" />
+      <LineId Id="234" Count="0" />
+      <LineId Id="233" Count="0" />
+      <LineId Id="228" Count="0" />
+      <LineId Id="230" Count="0" />
+      <LineId Id="229" Count="0" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="159" Count="0" />
+      <LineId Id="161" Count="0" />
+      <LineId Id="163" Count="1" />
+      <LineId Id="160" Count="0" />
+      <LineId Id="116" Count="3" />
+      <LineId Id="165" Count="3" />
+      <LineId Id="120" Count="10" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_SINT">
+      <LineId Id="212" Count="20" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="190" Count="0" />
+      <LineId Id="116" Count="14" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_UDINT">
+      <LineId Id="212" Count="20" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="190" Count="0" />
+      <LineId Id="116" Count="14" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_UINT">
+      <LineId Id="212" Count="20" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="190" Count="0" />
+      <LineId Id="116" Count="14" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_ULINT">
+      <LineId Id="212" Count="20" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="190" Count="0" />
+      <LineId Id="116" Count="14" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_USINT">
+      <LineId Id="212" Count="20" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="190" Count="0" />
+      <LineId Id="116" Count="14" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
+    <LineIds Name="FB_Assert.AssertArrayEquals_WORD">
+      <LineId Id="89" Count="0" />
+      <LineId Id="216" Count="1" />
+      <LineId Id="90" Count="0" />
+      <LineId Id="218" Count="0" />
+      <LineId Id="91" Count="0" />
+      <LineId Id="93" Count="2" />
+      <LineId Id="219" Count="0" />
+      <LineId Id="222" Count="1" />
+      <LineId Id="226" Count="1" />
+      <LineId Id="231" Count="1" />
+      <LineId Id="234" Count="0" />
+      <LineId Id="233" Count="0" />
+      <LineId Id="228" Count="0" />
+      <LineId Id="230" Count="0" />
+      <LineId Id="229" Count="0" />
+      <LineId Id="102" Count="12" />
+      <LineId Id="149" Count="0" />
+      <LineId Id="152" Count="0" />
+      <LineId Id="154" Count="1" />
+      <LineId Id="159" Count="0" />
+      <LineId Id="161" Count="0" />
+      <LineId Id="163" Count="1" />
+      <LineId Id="160" Count="0" />
+      <LineId Id="116" Count="3" />
+      <LineId Id="165" Count="3" />
+      <LineId Id="120" Count="10" />
+      <LineId Id="10" Count="0" />
+    </LineIds>
     <LineIds Name="FB_Assert.AssertEquals">
       <LineId Id="117" Count="0" />
       <LineId Id="115" Count="0" />