co♻e: unittest framework for CODESYS

--- a
+++ b/tags/v1.0.0.0/CfUnitVerifier.project.md
@@ -0,0 +1,4697 @@
+---
+
+                     This testsuite tests the function block FB_AdjustAssertFailureMessageToMax255CharLength_Test
+   The total printed message can not be more than 252 characters long.
+
+
+~~~ST
+FUNCTION_BLOCK FB_AdjustAssertFailureMessageToMax252CharLengthTest EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+TestInstancePath252CharsExpectTooLongTestInstancePath();
+TestInstancePath220CharsExpectShortenedTestInstancePath();
+TestInstancePath255CharsExpectTooLongTestInstancePath();
+~~~
+---
+~~~ST
+METHOD TestInstancePath220CharsExpectShortenedTestInstancePath: 
+VAR
+    AdjustAssertFailureMessageToMax252CharLength: FB_AdjustAssertFailureMessageToMax252CharLength;
+    TestInstancePathNameWith220Chars: T_MaxString;
+    TooLongTestMessage60Chars: T_MaxString;
+    TestMessageResultExpected: T_MaxString;
+    TestInstancePathResult: T_MaxString;
+    TestMessageResult: T_MaxString;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestInstancePath220CharsExpectShortenedTestInstancePath');
+
+AdjustAssertFailureMessageToMax252CharLength(MsgFmtString := TestInstancePathNameWith220Chars,
+                                             StringArg := TooLongTestMessage60Chars,
+                                             MsgFmtStringProcessed => TestInstancePathResult,
+                                             StringArgProcessed => TestMessageResult);
+
+
+AssertEquals_STRING(Expected := TestInstancePathNameWith220Chars, // Same test instance path should be expected as the one going in
+                    Actual := TestInstancePathResult,
+                    'Test instance path not correct');
+
+AssertEquals_STRING(Expected := TestMessageResultExpected,
+                    Actual := TestMessageResult,
+                    'Test message not correct');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD TestInstancePath252CharsExpectTooLongTestInstancePath: 
+VAR
+    AdjustAssertFailureMessageToMax252CharLength: FB_AdjustAssertFailureMessageToMax252CharLength;
+    TestInstancePathNameWith252Chars: T_MaxString;
+    ShortTestMessage: T_MaxString;
+    TestInstancePathNameWith252CharsExpectedResult: T_MaxString;
+    ShortTestMessageExpectedResult: T_MaxString;
+    TestInstancePathNameWith252CharsResult: T_MaxString;
+    ShortTestMessageResult: T_MaxString;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestInstancePath252CharsExpectTooLongTestInstancePath');
+
+AdjustAssertFailureMessageToMax252CharLength(MsgFmtString := TestInstancePathNameWith252Chars,
+                                             StringArg := ShortTestMessage,
+                                             MsgFmtStringProcessed => TestInstancePathNameWith252CharsResult,
+                                             StringArgProcessed => ShortTestMessageResult);
+
+AssertEquals_STRING(Expected := TestInstancePathNameWith252CharsExpectedResult,
+                    Actual := TestInstancePathNameWith252CharsResult,
+                    'Test instance path not correct');
+
+AssertEquals_STRING(Expected := ShortTestMessageExpectedResult,
+                    Actual := ShortTestMessageResult,
+                    'Test message not correct');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD TestInstancePath255CharsExpectTooLongTestInstancePath: 
+VAR
+    AdjustAssertFailureMessageToMax252CharLength: FB_AdjustAssertFailureMessageToMax252CharLength;
+    TestInstancePathNameWith255Chars: T_MaxString;
+    ShortTestMessage: T_MaxString;
+    TestInstancePathNameWith252CharsExpectedResult: T_MaxString;
+    ShortTestMessageExpectedResult: T_MaxString;
+    TestInstancePathNameWith252CharsResult: T_MaxString;
+    ShortTestMessageResult: T_MaxString;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestInstancePath255CharsExpectTooLongTestInstancePath');
+
+AdjustAssertFailureMessageToMax252CharLength(MsgFmtString := TestInstancePathNameWith255Chars,
+                                             StringArg := ShortTestMessage,
+                                             MsgFmtStringProcessed => TestInstancePathNameWith252CharsResult,
+                                             StringArgProcessed => ShortTestMessageResult);
+
+AssertEquals_STRING(Expected := TestInstancePathNameWith252CharsExpectedResult,
+                    Actual := TestInstancePathNameWith252CharsResult,
+                    'Test instance path not correct');
+
+AssertEquals_STRING(Expected := ShortTestMessageExpectedResult,
+                    Actual := ShortTestMessageResult,
+                    'Test message not correct');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    This testsuite tests the different assert-functions for all the primitive data types in TwinCAT, but using the
+    ANY-version of the Assert-method.
+    For every data type at least two different tests have been defined:
+        1. One test that succeeds (Expected and actual are equal)
+        2. One test that fails (Expected and actual are false).
+    For every failing test the printed value should be the same as if we were using the primitive data type assert
+    directly. 
+
+
+~~~ST
+FUNCTION_BLOCK FB_AnyPrimitiveTypes EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+Test_ANY_BYTE_Equals();
+Test_ANY_BYTE_Differ();
+Test_ANY_BOOL_Equals();
+Test_ANY_BOOL_Differ();
+Test_ANY_DATE_Equals();
+Test_ANY_DATE_Differ();
+Test_ANY_DATE_AND_TIME_Equals();
+Test_ANY_DATE_AND_TIME_Differ();
+Test_ANY_DINT_Equals();
+Test_ANY_DINT_Differ();
+Test_ANY_DWORD_Equals();
+Test_ANY_DWORD_Differ();
+Test_ANY_INT_Equals();
+Test_ANY_INT_Differ();
+Test_ANY_LINT_Equals();
+Test_ANY_LINT_Differ();
+Test_ANY_LREAL_Equals();
+Test_ANY_LREAL_Differ();
+Test_ANY_LTIME_Equals();
+Test_ANY_LTIME_Differ();
+Test_ANY_LWORD_Equals();
+Test_ANY_LWORD_Differ();
+Test_ANY_REAL_Equals();
+Test_ANY_REAL_Differ();
+Test_ANY_SINT_Equals();
+Test_ANY_SINT_Differ();
+Test_ANY_STRING_Equals();
+Test_ANY_STRING_Differ();
+Test_ANY_TIME_Equals();
+Test_ANY_TIME_Differ();
+Test_ANY_TIME_OF_DAY_Equals();
+TesT_ANY_TIME_OF_DAY_Differ();
+Test_ANY_UDINT_Equals();
+Test_ANY_UDINT_Differ();
+Test_ANY_UINT_Equals();
+Test_ANY_UINT_Differ();
+Test_ANY_ULINT_Equals();
+Test_ANY_ULINT_Differ();
+Test_ANY_USINT_Equals();
+Test_ANY_USINT_Differ();
+Test_ANY_WORD_Equals();
+Test_ANY_WORD_Differ();
+~~~
+---
+~~~ST
+METHOD Test_ANY_BOOL_Differ: 
+VAR
+    a: BOOL;
+    b: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_BOOL_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_BOOL_Equals: 
+VAR
+    a: BOOL;
+    b: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_BOOL_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_BYTE_Differ: 
+VAR
+    a: BYTE;
+    b: BYTE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_BYTE_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_BYTE_Equals: 
+VAR
+    a: BYTE;
+    b: BYTE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_BYTE_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DATE_AND_TIME_Differ: 
+VAR
+    a: DT;
+    b: DT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DATE_AND_TIME_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DATE_AND_TIME_Equals: 
+VAR
+    a: DT;
+    b: DT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DATE_AND_TIME_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DATE_Differ: 
+VAR
+    a: DATE;
+    b: DATE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DATE_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DATE_Equals: 
+VAR
+    a: DATE;
+    b: DATE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DATE_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DINT_Differ: 
+VAR
+    a: DINT;
+    b: DINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DINT_Equals: 
+VAR
+    a: DINT;
+    b: DINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DWORD_Differ: 
+VAR
+    a: DWORD;
+    b: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DWORD_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_DWORD_Equals: 
+VAR
+    a: DWORD;
+    b: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_DWORD_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_INT_Differ: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_INT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_INT_Equals: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_INT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LINT_Differ: 
+VAR
+    a: LINT;
+    b: LINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LINT_Equals: 
+VAR
+    a: LINT;
+    b: LINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LREAL_Differ: 
+VAR
+    a: LREAL;
+    b: LREAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LREAL_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LREAL_Equals: 
+VAR
+    a: LREAL;
+    b: LREAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LREAL_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LTIME_Differ: 
+VAR
+    a: LTIME;
+    b: LTIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LTIME_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LTIME_Equals: 
+VAR
+    a: LTIME;
+    b: LTIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LTIME_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LWORD_Differ: 
+VAR
+    a: LWORD;
+    b: LWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LWORD_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_LWORD_Equals: 
+VAR
+    a: LWORD;
+    b: LWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_LWORD_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_REAL_Differ: 
+VAR
+    a: REAL;
+    b: REAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_REAL_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_REAL_Equals: 
+VAR
+    a: REAL;
+    b: REAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_REAL_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_SINT_Differ: 
+VAR
+    a: SINT;
+    b: SINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_SINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_SINT_Equals: 
+VAR
+    a: SINT;
+    b: SINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_SINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_STRING_Differ: 
+VAR
+    a: string;
+    b: string;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_STRING_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_STRING_Equals: 
+VAR
+    a: string;
+    b: string;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_STRING_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_TIME_Differ: 
+VAR
+    a: TIME;
+    b: TIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_TIME_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_TIME_Equals: 
+VAR
+    a: TIME;
+    b: TIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_TIME_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_TIME_OF_DAY_Differ: 
+VAR
+    a: TOD;
+    b: TOD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_TIME_OF_DAY_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_TIME_OF_DAY_Equals: 
+VAR
+    a: TOD;
+    b: TOD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_TIME_OF_DAY_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_UDINT_Differ: 
+VAR
+    a: UDINT;
+    b: UDINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_UDINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_UDINT_Equals: 
+VAR
+    a: UDINT;
+    b: UDINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_UDINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_UINT_Differ: 
+VAR
+    a: UINT;
+    b: UINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_UINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_UINT_Equals: 
+VAR
+    a: UINT;
+    b: UINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_UINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_ULINT_Differ: 
+VAR
+    a: ULINT;
+    b: ULINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_ULINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_ULINT_Equals: 
+VAR
+    a: ULINT;
+    b: ULINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_ULINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_USINT_Differ: 
+VAR
+    a: USINT;
+    b: USINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_USINT_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_USINT_Equals: 
+VAR
+    a: USINT;
+    b: USINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_USINT_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_WORD_Differ: 
+VAR
+    a: WORD;
+    b: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_WORD_Differ');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_WORD_Equals: 
+VAR
+    a: WORD;
+    b: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_WORD_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    Tests the free function F_AnyToUnionValue.
+
+
+~~~ST
+FUNCTION_BLOCK FB_AnyToUnionValue EXTENDS CfUnit.FB_TestSuite
+VAR
+    aBit: BIT;
+END_VAR
+
+~~~
+~~~ST
+Test_BOOL();
+Test_BIT();
+Test_BYTE();
+Test_WORD();
+Test_DWORD();
+Test_LWORD();
+Test_SINT();
+Test_INT();
+Test_DINT();
+Test_LINT();
+Test_USINT();
+Test_UINT();
+Test_UDINT();
+Test_ULINT();
+Test_REAL();
+Test_LREAL();
+Test_STRING();
+Test_STRING_2();
+Test_WSTRING();
+Test_TIME();
+Test_DATE();
+Test_DATE_AND_TIME();
+Test_TIME_OF_DAY();
+Test_LTIME();
+~~~
+---
+~~~ST
+METHOD Test_BIT: 
+VAR
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BIT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := aBit);
+
+AssertEquals(Expected := aBit,
+             Actual := result.bitExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BOOL: 
+VAR
+    a: BOOL;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BOOL');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.boolExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BYTE: 
+VAR
+    a: BYTE;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BYTE');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.byteExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DATE: 
+VAR
+    a: DATE;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DATE');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.dateExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DATE_AND_TIME: 
+VAR
+    a: DT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DATE_AND_TIME');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.dateandtimeExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DINT: 
+VAR
+    a: DINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.dintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DWORD: 
+VAR
+    a: DWORD;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DWORD');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.dwordExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_INT: 
+VAR
+    a: INT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_INT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.intExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LINT: 
+VAR
+    a: LINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.lintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL: 
+VAR
+    a: LREAL;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.lrealExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LTIME: 
+VAR
+    a: LTIME;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LTIME');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.ltimeExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LWORD: 
+VAR
+    a: LWORD;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LWORD');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.lwordExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL: 
+VAR
+    a: REAL;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.realExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_SINT: 
+VAR
+    a: SINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_SINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.sintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_STRING: 
+VAR
+    a: string;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_STRING');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.stringExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_STRING_2: 
+VAR
+    a: T_MaxString;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_STRING_2');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.stringExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_TIME: 
+VAR
+    a: TIME;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_TIME');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.timeExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_TIME_OF_DAY: 
+VAR
+    a: TOD;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_TIME_OF_DAY');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.timeofdayExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UDINT: 
+VAR
+    a: UDINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UDINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.udintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UINT: 
+VAR
+    a: UINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.uintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ULINT: 
+VAR
+    a: ULINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('TEST_ULINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.ulintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_USINT: 
+VAR
+    a: USINT;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_USINT');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.usintExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WORD: 
+VAR
+    a: WORD;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WORD');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.wordExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WSTRING: 
+VAR
+    a: wstring;
+    result: U_ExpectedOrActual;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WSTRING');
+
+result := CfUnit.F_AnyToUnionValue(AnyValue := a);
+
+AssertEquals(Expected := a,
+             Actual := result.wstringExpectedOrActual,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    This testsuite tests the different assert-functions for all the different type of arrays (varying by the different
+    data types that are available in TwinCAT). For every type of array (BOOL, BYTE, INT etc.) at least three different
+    tests have been defined:
+        1. One test that succeeds, where the data and size of the arrays are matching
+        2. One test that fails, where the size of the arrays differs
+        3. One test that fails, where the content of the array differs
+
+
+~~~ST
+FUNCTION_BLOCK FB_ArrayPrimitiveTypes EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+Test_BOOL_Array_Equals();
+Test_BOOL_Array_DifferInSize();
+Test_BOOL_Array_DifferInContent();
+Test_BYTE_Array_Equals();
+Test_BYTE_Array_DifferInSize();
+Test_BYTE_Array_DifferInContent();
+Test_DINT_Array_Equals();
+Test_DINT_Array_DifferInSize();
+Test_DINT_Array_DifferInContent();
+Test_DWORD_Array_Equals();
+Test_DWORD_Array_DifferInSize();
+Test_DWORD_Array_DifferInContent();
+Test_INT_Array_Equals();
+Test_INT_Array_DifferInSize();
+Test_INT_Array_DifferInContent();
+Test_LINT_Array_Equals();
+Test_LINT_Array_DifferInSize();
+Test_LINT_Array_DifferInContent();
+Test_LREAL_Array_Equals();
+Test_LREAL_Array_DifferInSize();
+Test_LREAL_Array_DifferInContent();
+Test_LREAL_Array2d_Equals();
+Test_LREAL_Array2d_DifferInSize();
+Test_LREAL_Array2d_DifferInContent();
+Test_LREAL_Array3d_Equals();
+Test_LREAL_Array3d_DifferInSize();
+Test_LREAL_Array3d_DifferInContent();
+Test_LWORD_Array_Equals();
+Test_LWORD_Array_DifferInSize();
+Test_LWORD_Array_DifferInContent();
+Test_REAL_Array_Equals();
+Test_REAL_Array_DifferInSize();
+Test_REAL_Array_DifferInContent();
+Test_REAL_Array2d_Equals();
+Test_REAL_Array2d_DifferInSize();
+Test_REAL_Array2d_DifferInContent();
+Test_REAL_Array3d_Equals();
+Test_REAL_Array3d_DifferInSize();
+Test_REAL_Array3d_DifferInContent();
+Test_SINT_Array_Equals();
+Test_SINT_Array_DifferInSize();
+Test_SINT_Array_DifferInContent();
+Test_UDINT_Array_Equals();
+Test_UDINT_Array_DifferInSize();
+Test_UDINT_Array_DifferInContent();
+Test_UINT_Array_Equals();
+Test_UINT_Array_DifferInSize();
+Test_UINT_Array_DifferInContent();
+Test_ULINT_Array_Equals();
+Test_ULINT_Array_DifferInSize();
+Test_ULINT_Array_DifferInContent();
+Test_USINT_Array_Equals();
+Test_USINT_Array_DifferInSize();
+Test_USINT_Array_DifferInContent();
+Test_WORD_Array_Equals();
+Test_WORD_Array_DifferInSize();
+Test_WORD_Array_DifferInContent();
+
+~~~
+---
+~~~ST
+METHOD Test_BOOL_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BOOL_Array_DifferInContent');
+
+AssertArrayEquals_BOOL(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BOOL_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BOOL_Array_DifferInSize');
+
+AssertArrayEquals_BOOL(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BOOL_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BOOL_Array_Equals');
+
+AssertArrayEquals_BOOL(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BYTE_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BYTE_Array_DifferInContent');
+
+AssertArrayEquals_BYTE(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BYTE_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BYTE_Array_DifferInSize');
+
+AssertArrayEquals_BYTE(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BYTE_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BYTE_Array_Equals');
+
+AssertArrayEquals_BYTE(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DINT_Array_DifferInContent');
+
+AssertArrayEquals_DINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DINT_Array_DifferInSize');
+
+AssertArrayEquals_DINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DINT_Array_Equals');
+
+AssertArrayEquals_DINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DWORD_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DWORD_Array_DifferInContent');
+
+AssertArrayEquals_DWORD(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DWORD_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DWORD_Array_DifferInSize');
+
+AssertArrayEquals_DWORD(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DWORD_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DWORD_Array_Equals');
+
+AssertArrayEquals_DWORD(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_INT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_INT_Array_DifferInContent');
+
+AssertArrayEquals_INT(Expecteds := a,
+                      Actuals := b,
+                      Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_INT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_INT_Array_DifferInSize');
+
+AssertArrayEquals_INT(Expecteds := a,
+                      Actuals := b,
+                      Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_INT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_INT_Array_Equals');
+
+AssertArrayEquals_INT(Expecteds := a,
+                      Actuals := b,
+                      Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LINT_Array_DifferInContent');
+
+AssertArrayEquals_LINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LINT_Array_DifferInSize');
+
+AssertArrayEquals_LINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LINT_Array_Equals');
+
+AssertArrayEquals_LINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array_DifferInContent');
+
+AssertArrayEquals_LREAL(Expecteds := a,
+                        Actuals := b,
+                        Delta := 0.01,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array_DifferInSize');
+
+AssertArrayEquals_LREAL(Expecteds := a,
+                        Actuals := b,
+                        Delta := 0.01,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array_Equals');
+
+AssertArrayEquals_LREAL(Expecteds := a,
+                        Actuals := b,
+                        Delta := 0.01,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array2d_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array2d_DifferInContent');
+
+AssertArray2dEquals_LREAL(Expecteds := a,
+                          Actuals := b,
+                          Delta := 0.01,
+                          Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array2d_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array2d_DifferInSize');
+
+AssertArray2dEquals_LREAL(Expecteds := a,
+                          Actuals := b,
+                          Delta := 0.01,
+                          Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array2d_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array2d_Equals');
+
+AssertArray2dEquals_LREAL(Expecteds := a,
+                          Actuals := b,
+                          Delta := 0.01,
+                          Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array3d_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array3d_DifferInContent');
+
+AssertArray3dEquals_LREAL(Expecteds := a,
+                          Actuals := b,
+                          Delta := 0.01,
+                          Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array3d_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array3d_DifferInSize');
+
+AssertArray3dEquals_LREAL(Expecteds := a,
+                          Actuals := b,
+                          Delta := 0.01,
+                          Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Array3d_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Array3d_Equals');
+
+AssertArray3dEquals_LREAL(Expecteds := a,
+                          Actuals := b,
+                          Delta := 0.01,
+                          Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LWORD_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LWORD_Array_DifferInContent');
+
+AssertArrayEquals_LWORD(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LWORD_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LWORD_Array_DifferInSize');
+
+AssertArrayEquals_LWORD(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LWORD_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LWORD_Array_Equals');
+
+AssertArrayEquals_LWORD(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array_DifferInContent');
+
+AssertArrayEquals_REAL(Expecteds := a,
+                       Actuals := b,
+                       Delta := 0.01,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array_DifferInSize');
+
+AssertArrayEquals_REAL(Expecteds := a,
+                       Actuals := b,
+                       Delta := 0.01,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array_Equals');
+
+AssertArrayEquals_REAL(Expecteds := a,
+                       Actuals := b,
+                       Delta := 0.01,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array2d_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array2d_DifferInContent');
+
+AssertArray2dEquals_REAL(Expecteds := a,
+                         Actuals := b,
+                         Delta := 0.01,
+                         Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array2d_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array2d_DifferInSize');
+
+AssertArray2dEquals_REAL(Expecteds := a,
+                         Actuals := b,
+                         Delta := 0.01,
+                         Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array2d_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array2d_Equals');
+
+AssertArray2dEquals_REAL(Expecteds := a,
+                         Actuals := b,
+                         Delta := 0.01,
+                         Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array3d_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array3d_DifferInContent');
+
+AssertArray3dEquals_REAL(Expecteds := a,
+                         Actuals := b,
+                         Delta := 0.01,
+                         Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array3d_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array3d_DifferInSize');
+
+AssertArray3dEquals_REAL(Expecteds := a,
+                         Actuals := b,
+                         Delta := 0.01,
+                         Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Array3d_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Array3d_Equals');
+
+AssertArray3dEquals_REAL(Expecteds := a,
+                         Actuals := b,
+                         Delta := 0.01,
+                         Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_SINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_SINT_Array_DifferInContent');
+
+AssertArrayEquals_SINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_SINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_SINT_Array_DifferInSize');
+
+AssertArrayEquals_SINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_SINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_SINT_Array_Equals');
+
+AssertArrayEquals_SINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UDINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UDINT_Array_DifferInContent');
+
+AssertArrayEquals_UDINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UDINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UDINT_Array_DifferInSize');
+
+AssertArrayEquals_UDINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UDINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UDINT_Array_Equals');
+
+AssertArrayEquals_UDINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UINT_Array_DifferInContent');
+
+AssertArrayEquals_UINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UINT_Array_DifferInSize');
+
+AssertArrayEquals_UINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UINT_Array_Equals');
+
+AssertArrayEquals_UINT(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ULINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ULINT_Array_DifferInContent');
+
+AssertArrayEquals_ULINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ULINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ULINT_Array_DifferInSize');
+
+AssertArrayEquals_ULINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ULINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ULINT_Array_Equals');
+
+AssertArrayEquals_ULINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_USINT_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_USINT_Array_DifferInContent');
+
+AssertArrayEquals_USINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_USINT_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_USINT_Array_DifferInSize');
+
+AssertArrayEquals_USINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_USINT_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_USINT_Array_Equals');
+
+AssertArrayEquals_USINT(Expecteds := a,
+                        Actuals := b,
+                        Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WORD_Array_DifferInContent: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WORD_Array_DifferInContent');
+
+AssertArrayEquals_WORD(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WORD_Array_DifferInSize: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WORD_Array_DifferInSize');
+
+AssertArrayEquals_WORD(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WORD_Array_Equals: 
+VAR
+    a: ARRAY [..] OF ;
+    b: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WORD_Array_Equals');
+
+AssertArrayEquals_WORD(Expecteds := a,
+                       Actuals := b,
+                       Message := 'Arrays differ');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    In this testsuite we are running the same testcase over two cycles, and thus calling every assert method twice.
+    This is in order to verify that we don't print every FAILED assert twice.
+
+
+~~~ST
+FUNCTION_BLOCK FB_AssertEveryFailedTestTwice EXTENDS CfUnit.FB_TestSuite
+VAR
+    AssertCount: USINT;
+END_VAR
+
+~~~
+~~~ST
+TwiceAssertCall();
+~~~
+---
+~~~ST
+METHOD TwiceAssertCall: 
+VAR
+    aANY: INT;
+    bANY: INT;
+    aBOOL: BOOL;
+    bBOOL: BOOL;
+    aBYTE: BYTE;
+    bBYTE: BYTE;
+    aDATE: DATE;
+    bDATE: DATE;
+    aDATE_AND_TIME: DT;
+    bDATE_AND_TIME: DT;
+    aDINT: DINT;
+    bDINT: DINT;
+    aDWORD: DWORD;
+    bDWORD: DWORD;
+    aINT: INT;
+    bINT: INT;
+    aLINT: LINT;
+    bLINT: LINT;
+    aLREAL: LREAL;
+    bLREAL: LREAL;
+    aLTIME: LTIME;
+    bLTIME: LTIME;
+    aLWORD: LWORD;
+    bLWORD: LWORD;
+    aREAL: REAL;
+    bREAL: REAL;
+    aSINT: SINT;
+    bSINT: SINT;
+    aSTRING: string;
+    bSTRING: string;
+    aUDINT: UDINT;
+    bUDINT: UDINT;
+    aUINT: UINT;
+    bUINT: UINT;
+    aULINT: ULINT;
+    bULINT: ULINT;
+    aUSINT: USINT;
+    bUSINT: USINT;
+    aTIME: TIME;
+    bTIME: TIME;
+    aTIME_OF_DAY: TOD;
+    bTIME_OF_DAY: TOD;
+    aWORD: WORD;
+    bWORD: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('TwiceAssertCall');
+
+AssertEquals(Expected := aANY,
+             Actual := bANY,
+             Message := 'Not equal ANY');
+
+AssertEquals_BOOL(Expected := aBOOL,
+                  Actual := bBOOL,
+                  Message := 'Not equal BOOL');
+
+AssertEquals_BYTE(Expected := aBYTE,
+                  Actual := bBYTE,
+                  Message := 'Not equal BYTE');
+
+AssertEquals_DATE(Expected := aDATE,
+                  Actual := bDATE,
+                  Message := 'Not equal DATE');
+
+AssertEquals_DATE_AND_TIME(Expected := aDATE_AND_TIME,
+                           Actual := bDATE_AND_TIME,
+                           Message := 'Not equal DATE_AND_TIME');
+
+AssertEquals_DINT(Expected := aDINT,
+                  Actual := bDINT,
+                  Message := 'Not equal DINT');
+
+AssertEquals_DWORD(Expected := aDWORD,
+                   Actual := bDWORD,
+                   Message := 'Not equal DWORD');
+
+AssertEquals_INT(Expected := aINT,
+                 Actual := bINT,
+                 Message := 'Not equal INT');
+
+AssertEquals_LINT(Expected := aLINT,
+                  Actual := bLINT,
+                  Message := 'Not equal LINT');
+
+AssertEquals_LREAL(Expected := aLREAL,
+                   Actual := bLREAL,
+                   Delta := 0.1,
+                   Message := 'Not equal LREAL');
+
+AssertEquals_LTIME(Expected := aLTIME,
+                   Actual := bLTIME,
+                   Message := 'Not equal LTIME');
+
+AssertEquals_LWORD(Expected := aLWORD,
+                   Actual := bLWORD,
+                   Message := 'Not equal LWORD');
+
+AssertEquals_REAL(Expected := aREAL,
+                  Actual := bREAL,
+                  Delta := 0.1,
+                  Message := 'Not equal REAL');
+
+AssertEquals_SINT(Expected := aSINT,
+                  Actual := bSINT,
+                  Message := 'Not equal SINT');
+
+AssertEquals_STRING(Expected := aSTRING,
+                    Actual := bSTRING,
+                    Message := 'Not equal STRING');
+
+AssertEquals_UDINT(Expected := aUDINT,
+                   Actual := bUDINT,
+                   Message := 'Not equal UDINT');
+
+AssertEquals_UINT(Expected := aUINT,
+                  Actual := bUINT,
+                  Message := 'Not equal UINT');
+
+AssertEquals_ULINT(Expected := aULINT,
+                   Actual := bULINT,
+                   Message := 'Not equal ULINT');
+
+AssertEquals_USINT(Expected := aUSINT,
+                   Actual := bUSINT,
+                   Message := 'Not equal USINT');
+
+AssertEquals_TIME(Expected := aTIME,
+                  Actual := bTIME,
+                  Message := 'Not equal TIME');
+
+AssertEquals_TIME_OF_DAY(Expected := aTIME_OF_DAY,
+                         Actual := bTIME_OF_DAY,
+                         Message := 'Not equal TIME_OF_DAY');
+
+AssertEquals_WORD(Expected := aWORD,
+                  Actual := bWORD,
+                  Message := 'Not equal WORD');
+
+AssertCount := AssertCount + 1;
+IF AssertCount = 2 THEN
+    TEST_FINISHED();
+END_IF
+~~~
+---
+
+                    
+    In this testsuite we are running the same testcase over two cycles, and thus calling
+    every assert method twice. This is in order to verify that we don't print every FAILED assert twice.
+    With this version we are doing it with arrays.
+
+
+~~~ST
+FUNCTION_BLOCK FB_AssertEveryFailedTestTwiceArrayVersion EXTENDS CfUnit.FB_TestSuite
+VAR
+    AssertCount: USINT;
+END_VAR
+
+~~~
+~~~ST
+TwiceAssertCall_Arrays();
+~~~
+---
+~~~ST
+METHOD TwiceAssertCall_Arrays: 
+VAR
+    aBOOL: ARRAY [..] OF ;
+    bBOOL: ARRAY [..] OF ;
+    aBYTE: ARRAY [..] OF ;
+    bBYTE: ARRAY [..] OF ;
+    aDINT: ARRAY [..] OF ;
+    bDINT: ARRAY [..] OF ;
+    aDWORD: ARRAY [..] OF ;
+    bDWORD: ARRAY [..] OF ;
+    aINT: ARRAY [..] OF ;
+    bINT: ARRAY [..] OF ;
+    aLINT: ARRAY [..] OF ;
+    bLINT: ARRAY [..] OF ;
+    aLREAL: ARRAY [..] OF ;
+    bLREAL: ARRAY [..] OF ;
+    aLREAL2d: ARRAY [..] OF ;
+    bLREAL2d: ARRAY [..] OF ;
+    aLREAL3d: ARRAY [..] OF ;
+    bLREAL3d: ARRAY [..] OF ;
+    aLWORD: ARRAY [..] OF ;
+    bLWORD: ARRAY [..] OF ;
+    aREAL: ARRAY [..] OF ;
+    bREAL: ARRAY [..] OF ;
+    aREAL2d: ARRAY [..] OF ;
+    bREAL2d: ARRAY [..] OF ;
+    aREAL3d: ARRAY [..] OF ;
+    bREAL3d: ARRAY [..] OF ;
+    aSINT: ARRAY [..] OF ;
+    bSINT: ARRAY [..] OF ;
+    aUDINT: ARRAY [..] OF ;
+    bUDINT: ARRAY [..] OF ;
+    aUINT: ARRAY [..] OF ;
+    bUINT: ARRAY [..] OF ;
+    aULINT: ARRAY [..] OF ;
+    bULINT: ARRAY [..] OF ;
+    aUSINT: ARRAY [..] OF ;
+    bUSINT: ARRAY [..] OF ;
+    aWORD: ARRAY [..] OF ;
+    bWORD: ARRAY [..] OF ;
+END_VAR
+
+~~~
+~~~ST
+TEST('TwiceAssertCall_Arrays');
+
+AssertArrayEquals_BOOL(Expecteds := aBOOL,
+                       Actuals := bBOOL,
+                       Message := 'Not equal BOOL');
+
+AssertArrayEquals_BYTE(Expecteds := aBYTE,
+                       Actuals := bBYTE,
+                       Message := 'Not equal BYTE');
+
+AssertArrayEquals_DINT(Expecteds := aDINT,
+                       Actuals := bDINT,
+                       Message := 'Not equal DINT');
+
+AssertArrayEquals_DWORD(Expecteds := aDWORD,
+                        Actuals := bDWORD,
+                        Message := 'Not equal DWORD');
+
+AssertArrayEquals_INT(Expecteds := aINT,
+                      Actuals := bINT,
+                      Message := 'Not equal INT');
+
+AssertArrayEquals_LINT(Expecteds := aLINT,
+                       Actuals := bLINT,
+                       Message := 'Not equal LINT');
+
+AssertArrayEquals_LREAL(Expecteds := aLREAL,
+                        Actuals := bLREAL,
+                        Delta := 0.1,
+                        Message := 'Not equal LREAL');
+
+AssertArray2dEquals_LREAL(Expecteds := aLREAL2d,
+                          Actuals := bLREAL2d,
+                          Delta := 0.1,
+                          Message := 'Not equal LREAL2D');
+
+AssertArray3dEquals_LREAL(Expecteds := aLREAL3d,
+                          Actuals := bLREAL3d,
+                          Delta := 0.1,
+                          Message := 'Not equal LREAL3D');
+
+AssertArrayEquals_LWORD(Expecteds := aLWORD,
+                        Actuals := bLWORD,
+                        Message := 'Not equal LWORD');
+
+AssertArrayEquals_SINT(Expecteds := aSINT,
+                       Actuals := bSINT,
+                       Message := 'Not equal SINT');
+
+AssertArrayEquals_REAL(Expecteds := aREAL,
+                       Actuals := bREAL,
+                       Delta := 0.00001,
+                       Message := 'Not equal REAL');
+
+AssertArray2dEquals_REAL(Expecteds := aREAL2d,
+                         Actuals := bREAL2d,
+                         Delta := 0.0001,
+                         Message := 'Not equal REAL2D');
+
+AssertArray3dEquals_REAL(Expecteds := aREAL3d,
+                         Actuals := bREAL3d,
+                         Delta := 0.01,
+                         Message := 'Not equal REAL3D');
+
+AssertArrayEquals_UDINT(Expecteds := aUDINT,
+                        Actuals := bUDINT,
+                        Message := 'Not equal UDINT');
+
+AssertArrayEquals_UINT(Expecteds := aUINT,
+                       Actuals := bUINT,
+                       Message := 'Not equal UINT');
+
+AssertArrayEquals_ULINT(Expecteds := aULINT,
+                        Actuals := bULINT,
+                        Message := 'Not equal ULINT');
+
+AssertArrayEquals_USINT(Expecteds := aUSINT,
+                        Actuals := bUSINT,
+                        Message := 'Not equal USINT');
+
+AssertArrayEquals_WORD(Expecteds := aWORD,
+                       Actuals := bWORD,
+                       Message := 'Not equal WORD');
+
+AssertCount := AssertCount + 1;
+IF AssertCount = 2 THEN
+    TEST_FINISHED();
+END_IF
+~~~
+---
+
+                     
+    This testsuite verifies that the Assert_True and Assert_False methods do what they are supposed to. It does so
+    by making sure that every assert-method (assert_true & assert_false) does both one failing and one successful
+    assert.
+
+
+~~~ST
+FUNCTION_BLOCK FB_AssertTrueFalse EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+AssertThatINTsAreEqual();
+AssertThatINTsAreNotEqual();
+AssertThatWORDsAreEqual();
+AssertThatWORDsAreNotEqual();
+~~~
+---
+~~~ST
+METHOD AssertThatINTsAreEqual: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('AssertThatINTsAreEqual');
+
+AssertFalse(Condition := (a <> b),
+            Message := 'INTs are equal');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD AssertThatINTsAreNotEqual: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('AssertThatINTsAreNotEqual');
+
+AssertFalse(Condition := (a = b),
+            Message := 'INTs are equal');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD AssertThatWORDsAreEqual: 
+VAR
+    a: WORD;
+    b: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('AssertThatWORDsAreEqual');
+
+AssertTrue(Condition := (a = b),
+           Message := 'WORDs are not equal');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD AssertThatWORDsAreNotEqual: 
+VAR
+    a: WORD;
+    b: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('AssertThatWORDsAreNotEqual');
+
+AssertTrue(Condition := (a <> b),
+           Message := 'WORDs are equal');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    Verifies that the function IS_TEST_FINISHED('Name') works as intended.
+
+
+~~~ST
+FUNCTION_BLOCK FB_CheckIfSpecificTestIsFinished EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+CheckBeforeAndAfterFinishing();
+~~~
+---
+~~~ST
+METHOD CheckBeforeAndAfterFinishing: 
+
+~~~
+~~~ST
+TEST('CheckBeforeAndAfterFinishing');
+
+AssertEquals_BOOL(Expected := FALSE,
+                  Actual := IS_TEST_FINISHED('CheckBeforeAndAfterFinishing'),
+                  Message:='Values differ before finishing');
+
+TEST_FINISHED();
+
+AssertEquals_BOOL(Expected := TRUE,
+                  Actual := IS_TEST_FINISHED('CheckBeforeAndAfterFinishing'),
+                  Message:='Values differ after finishing');
+~~~
+---
+
+                    
+    This testsuite runs two tests. One that is enabled (and that is supposed to fail), and one that is disabled (and
+    even though it also is failing is not supposed to run).
+
+
+~~~ST
+FUNCTION_BLOCK FB_CreateDisabledTest EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+TestEnabled();
+TestDisabled();
+~~~
+---
+~~~ST
+METHOD TestDisabled: 
+VAR
+    a: BOOL;
+    b: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('DISABLED_ThisShouldNotExecute');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'A does not equal B');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD TestEnabled: 
+VAR
+    a: BOOL;
+    b: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestEnabled');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'A does not equal B');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    This testsuite creates four tests in the same testsuite with the same name. Every test in a testsuite should have
+    an unique name. Every assert should be ignored if a duplicate test is being run.
+
+
+~~~ST
+FUNCTION_BLOCK FB_CreateFourTestsWithSameName EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+TestOne();
+TestOne_Again();
+TestOne_AgainAgain();
+TestOne_AgainAgainAgain();
+~~~
+---
+~~~ST
+METHOD TestOne: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestOne');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'A does not equal B');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD TestOne_Again: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestOne');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'A does not equal B again');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD TestOne_AgainAgain: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestOne');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'A does not equal B again');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD TestOne_AgainAgainAgain: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('TestOne');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'A does not equal B again');
+
+TEST_FINISHED();
+~~~
+---
+
+                     This is an empty testsuite with no test cases, so that we can verify that the system still prints the
+   test results. 
+
+~~~ST
+FUNCTION_BLOCK FB_EmptyTestSuite EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+
+~~~
+---
+
+                    
+    This test-suite runs several asserts with the same parameters (same expected, actual, message), calling the asserts
+    in different cycles and using the same test.
+    On top of this, we will call new asserts (though with same parameters) in later cycles.
+    The reason we want the framework to support this is that theoretically the user could want to do an assert with the
+    same message, using the same test with the same data values for both expected and actual, and splitting the asserts
+    on different cycles.
+
+
+~~~ST
+FUNCTION_BLOCK FB_MultipleAssertWithSameParametersInDifferentCyclesAndInSameTest EXTENDS CfUnit.FB_TestSuite
+VAR
+    TimerAgain: TON;
+    TimerAgainAgain: TON;
+    CalledAll: BOOL;
+END_VAR
+
+~~~
+~~~ST
+Assert_SeveralTimes();
+~~~
+---
+~~~ST
+METHOD Assert_SeveralTimes: 
+VAR
+    a: DWORD;
+    b: DWORD;
+    c: DWORD;
+    d: DWORD;
+    e: DWORD;
+    f: DWORD;
+    g: DWORD;
+    h: DWORD;
+    i: DWORD;
+    j: DWORD;
+    k: DWORD;
+    l: DWORD;
+    m: DWORD;
+    n: DWORD;
+    o: DWORD;
+    p: DWORD;
+    q: DWORD;
+    rr: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Assert_SeveralTimes');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+AssertEquals_DWORD(Expected := c,
+                   Actual := d,
+                   Message := 'Values differ');
+AssertEquals_DWORD(Expected := e,
+                   Actual := f,
+                   Message := 'Values differ');
+
+TimerAgain(IN := TRUE);
+IF TimerAgain.Q THEN
+    TimerAgainAgain(IN := TRUE);
+    AssertEquals_DWORD(Expected := g,
+                       Actual := h,
+                       Message := 'Values differ');
+    AssertEquals_DWORD(Expected := i,
+                       Actual := j,
+                       Message := 'Values differ');
+    AssertEquals_DWORD(Expected := k,
+                       Actual := l,
+                       Message := 'Values differ');
+END_IF
+
+IF TimerAgainAgain.Q THEN
+    AssertEquals_DWORD(Expected := m,
+                       Actual := n,
+                       Message := 'Values differ');
+    AssertEquals_DWORD(Expected := o,
+                       Actual := p,
+                       Message := 'Values differ');
+    AssertEquals_DWORD(Expected := q,
+                       Actual := rr,
+                       Message := 'Values differ');
+    CalledAll := TRUE;
+    TEST_FINISHED();
+END_IF
+~~~
+---
+
+                    
+    This test-suite runs several asserts with the same parameters (same expected, actual, message), calling the asserts
+    in different cycles and using different tests.
+    On top of this, we will call new asserts (though with same parameters) in later cycles.
+    The reason we want the framework to support this is that theoretically the user could want to do an assert with the
+    same message, in different tests, with the same data values for both expected and actual, although the data that the
+    user does the assert on might be from different data sets.
+
+
+~~~ST
+FUNCTION_BLOCK FB_MultipleAssertWithSameParametersInDifferentCyclesButWithDifferentTests EXTENDS CfUnit.FB_TestSuite
+VAR
+    TimerAgain: TON;
+    TimerAgainAgain: TON;
+    CalledAll: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TimerAgain(IN := TRUE);
+
+Assert_SeveralTimes();
+
+IF TimerAgain.Q THEN
+    TimerAgainAgain(IN := TRUE);
+    Assert_SeveralTimesAgain();
+END_IF
+
+IF TimerAgainAgain.Q THEN
+    Assert_SeveralTimesAgainAgain();
+    CalledAll := TRUE;
+END_IF
+~~~
+---
+~~~ST
+METHOD Assert_SeveralTimes: 
+VAR
+    a: DWORD;
+    b: DWORD;
+    c: DWORD;
+    d: DWORD;
+    e: DWORD;
+    f: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Assert_SeveralTimes');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := c,
+                   Actual := d,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := e,
+                   Actual := f,
+                   Message := 'Values differ');
+
+IF CalledAll THEN
+    TEST_FINISHED();
+END_IF
+~~~
+---
+~~~ST
+METHOD Assert_SeveralTimesAgain: 
+VAR
+    a: DWORD;
+    b: DWORD;
+    c: DWORD;
+    d: DWORD;
+    e: DWORD;
+    f: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Assert_SeveralTimesAgain');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := c,
+                   Actual := d,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := e,
+                   Actual := f,
+                   Message := 'Values differ');
+
+IF CalledAll THEN
+    TEST_FINISHED();
+END_IF
+~~~
+---
+~~~ST
+METHOD Assert_SeveralTimesAgainAgain: 
+VAR
+    a: DWORD;
+    b: DWORD;
+    c: DWORD;
+    d: DWORD;
+    e: DWORD;
+    f: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Assert_SeveralTimesAgainAgain');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := c,
+                   Actual := d,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := e,
+                   Actual := f,
+                   Message := 'Values differ');
+
+IF CalledAll THEN
+    TEST_FINISHED();
+END_IF
+~~~
+---
+
+                    
+    This test-suite runs several asserts with the same parameters (same expected, actual, message) in the same cycle
+    and in the same test.
+    The reason we want the framework to support this is that theoretically the user could want to do an assert with the
+    same message, in the same test, with the same data values for both expected and actual, although the data that the
+    user does the assert on might be from different data sets.
+
+
+~~~ST
+FUNCTION_BLOCK FB_MultipleAssertWithSameParametersInSameCycleWithSameTest EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+Assert_SeveralTimes();
+~~~
+---
+~~~ST
+METHOD Assert_SeveralTimes: 
+VAR
+    a: DWORD;
+    b: DWORD;
+    c: DWORD;
+    d: DWORD;
+    e: DWORD;
+    f: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Assert_SeveralTimes');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := c,
+                   Actual := d,
+                   Message := 'Values differ');
+
+AssertEquals_DWORD(Expected := e,
+                   Actual := f,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    This testsuite tests the different assert-functions for all the different data types in TwinCAT.
+    For every data type at least two different tests have been defined:
+        1. One test that succeeds (Expected and actual are equal)
+        2. One test that fails (Expected and actual are false).
+
+
+~~~ST
+FUNCTION_BLOCK FB_PrimitiveTypes EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+Test_ANY_Equals();
+Test_ANY_Differ_DataType();
+Test_BOOL_Equals();
+Test_BOOL_Differ();
+Test_BYTE_Equals();
+Test_BYTE_Differ();
+Test_DATE_AND_TIME_Equals();
+Test_DATE_AND_TIME_Differ();
+Test_DATE_Equals();
+Test_DATE_Differ();
+Test_DINT_Equals();
+Test_DINT_Differ();
+Test_DWORD_Equals();
+Test_DWORD_Differ();
+Test_INT_Equals();
+Test_INT_Differ();
+Test_LINT_Equals();
+Test_LINT_Differ();
+Test_LREAL_Equals();
+Test_LREAL_Differ();
+Test_LTIME_Equals();
+Test_LTIME_Differ();
+Test_LWORD_Equals();
+Test_LWORD_Differ();
+Test_REAL_Equals();
+Test_REAL_Differ();
+Test_SINT_Equals();
+Test_SINT_Differ();
+Test_STRING_Equals();
+Test_STRING_Differ();
+Test_TIME_Equals();
+Test_TIME_Differ();
+Test_TIME_OF_DAY_Equals();
+Test_TIME_OF_DAY_Differ();
+Test_UDINT_Equals();
+Test_UDINT_Differ();
+Test_UINT_Equals();
+Test_UINT_Differ();
+Test_ULINT_Equals();
+Test_ULINT_Differ();
+Test_USINT_Equals();
+Test_USINT_Differ();
+Test_WORD_Equals();
+Test_WORD_Differ();
+~~~
+---
+~~~ST
+METHOD Test_ANY_Differ_DataType: 
+VAR
+    a: INT;
+    b: UINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_Differ_DataType');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ANY_Equals: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ANY_Equals');
+
+AssertEquals(Expected := a,
+             Actual := b,
+             Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BOOL_Differ: 
+VAR
+    a: BOOL;
+    b: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BOOL_Differ');
+
+AssertEquals_BOOL(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BOOL_Equals: 
+VAR
+    a: BOOL;
+    b: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BOOL_Equals');
+
+AssertEquals_BOOL(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BYTE_Differ: 
+VAR
+    a: BYTE;
+    b: BYTE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BYTE_Differ');
+
+AssertEquals_BYTE(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_BYTE_Equals: 
+VAR
+    a: BYTE;
+    b: BYTE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_BYTE_Equals');
+
+AssertEquals_BYTE(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DATE_AND_TIME_Differ: 
+VAR
+    a: DT;
+    b: DT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DATE_AND_TIME_Differ');
+
+AssertEquals_DATE_AND_TIME(Expected := a,
+                           Actual := b,
+                           Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DATE_AND_TIME_Equals: 
+VAR
+    a: DT;
+    b: DT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DATE_AND_TIME_Equals');
+
+AssertEquals_DATE_AND_TIME(Expected := a,
+                           Actual := b,
+                           Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DATE_Differ: 
+VAR
+    a: DATE;
+    b: DATE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DATE_Differ');
+
+AssertEquals_DATE(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DATE_Equals: 
+VAR
+    a: DATE;
+    b: DATE;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DATE_Equals');
+
+AssertEquals_DATE(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DINT_Differ: 
+VAR
+    a: DINT;
+    b: DINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DINT_Differ');
+
+AssertEquals_DINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DINT_Equals: 
+VAR
+    a: DINT;
+    b: DINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DINT_Equals');
+
+AssertEquals_DINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DWORD_Differ: 
+VAR
+    a: DWORD;
+    b: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DWORD_Differ');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_DWORD_Equals: 
+VAR
+    a: DWORD;
+    b: DWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_DWORD_Equals');
+
+AssertEquals_DWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_INT_Differ: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_INT_Differ');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_INT_Equals: 
+VAR
+    a: INT;
+    b: INT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_INT_Equals');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LINT_Differ: 
+VAR
+    a: LINT;
+    b: LINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LINT_Differ');
+
+AssertEquals_LINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LINT_Equals: 
+VAR
+    a: LINT;
+    b: LINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LINT_Equals');
+
+AssertEquals_LINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Differ: 
+VAR
+    a: LREAL;
+    b: LREAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Differ');
+
+AssertEquals_LREAL(Expected := a,
+                   Actual := b,
+                   Delta := 0.1,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LREAL_Equals: 
+VAR
+    a: LREAL;
+    b: LREAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LREAL_Equals');
+
+AssertEquals_LREAL(Expected := a,
+                   Actual := b,
+                   Delta := 0.2,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LTIME_Differ: 
+VAR
+    a: LTIME;
+    b: LTIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LTIME_Differ');
+
+AssertEquals_LTIME(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LTIME_Equals: 
+VAR
+    a: LTIME;
+    b: LTIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LTIME_Equals');
+
+AssertEquals_LTIME(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LWORD_Differ: 
+VAR
+    a: LWORD;
+    b: LWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LWORD_Differ');
+
+AssertEquals_LWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_LWORD_Equals: 
+VAR
+    a: LWORD;
+    b: LWORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_LWORD_Equals');
+
+AssertEquals_LWORD(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Differ: 
+VAR
+    a: REAL;
+    b: REAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Differ');
+
+AssertEquals_REAL(Expected := a,
+                  Actual := b,
+                  Delta := 0.05,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_REAL_Equals: 
+VAR
+    a: REAL;
+    b: REAL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_REAL_Equals');
+
+AssertEquals_REAL(Expected := a,
+                  Actual := b,
+                  Delta := 0.1,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_SINT_Differ: 
+VAR
+    a: SINT;
+    b: SINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_SINT_Differ');
+
+AssertEquals_SINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_SINT_Equals: 
+VAR
+    a: SINT;
+    b: SINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_SINT_Equals');
+
+AssertEquals_SINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_STRING_Differ: 
+VAR
+    a: string;
+    b: string;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_STRING_Differ');
+
+AssertEquals_STRING(Expected := a,
+                    Actual := b,
+                    Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_STRING_Equals: 
+VAR
+    a: string;
+    b: string;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_STRING_Equals');
+
+AssertEquals_STRING(Expected := a,
+                    Actual := b,
+                    Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_TIME_Differ: 
+VAR
+    a: TIME;
+    b: TIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_TIME_Differ');
+
+AssertEquals_TIME(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_TIME_Equals: 
+VAR
+    a: TIME;
+    b: TIME;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_TIME_Equals');
+
+AssertEquals_TIME(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_TIME_OF_DAY_Differ: 
+VAR
+    a: TOD;
+    b: TOD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_TIME_OF_DAY_Differ');
+
+AssertEquals_TIME_OF_DAY(Expected := a,
+                         Actual := b,
+                         Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_TIME_OF_DAY_Equals: 
+VAR
+    a: TOD;
+    b: TOD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_TIME_OF_DAY_Equals');
+
+AssertEquals_TIME_OF_DAY(Expected := a,
+                         Actual := b,
+                         Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UDINT_Differ: 
+VAR
+    a: UDINT;
+    b: UDINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UDINT_Differ');
+
+AssertEquals_UDINT(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UDINT_Equals: 
+VAR
+    a: UDINT;
+    b: UDINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UDINT_Equals');
+
+AssertEquals_UDINT(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UINT_Differ: 
+VAR
+    a: UINT;
+    b: UINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UINT_Differ');
+
+AssertEquals_UINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_UINT_Equals: 
+VAR
+    a: UINT;
+    b: UINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_UINT_Equals');
+
+AssertEquals_UINT(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ULINT_Differ: 
+VAR
+    a: ULINT;
+    b: ULINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ULINT_Differ');
+
+AssertEquals_ULINT(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_ULINT_Equals: 
+VAR
+    a: ULINT;
+    b: ULINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_ULINT_Equals');
+
+AssertEquals_ULINT(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_USINT_Differ: 
+VAR
+    a: USINT;
+    b: USINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_USINT_Differ');
+
+AssertEquals_USINT(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_USINT_Equals: 
+VAR
+    a: USINT;
+    b: USINT;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_USINT_Equals');
+
+AssertEquals_USINT(Expected := a,
+                   Actual := b,
+                   Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WORD_Differ: 
+VAR
+    a: WORD;
+    b: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WORD_Differ');
+
+AssertEquals_WORD(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WORD_Equals: 
+VAR
+    a: WORD;
+    b: WORD;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WORD_Equals');
+
+AssertEquals_WORD(Expected := a,
+                  Actual := b,
+                  Message := 'Values differ');
+
+TEST_FINISHED();
+~~~
+---
+
+                     This function blocks tests the TEST_FINISHED_NAMED function by creating various tests
+   and finishing them in steps 
+
+~~~ST
+FUNCTION_BLOCK FB_TestFinishedNamed EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+
+~~~
+---
+
+                    
+    This testsuite tests the WRITE_PROTECTED_* helper functions.
+
+
+~~~ST
+FUNCTION_BLOCK FB_WriteProtectedFunctions EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+Test_WRITE_PROTECTED_BOOL();
+Test_WRITE_PROTECTED_BYTE();
+Test_WRITE_PROTECTED_DATE();
+Test_WRITE_PROTECTED_DATE_AND_TIME();
+Test_WRITE_PROTECTED_DINT();
+Test_WRITE_PROTECTED_DWORD();
+Test_WRITE_PROTECTED_INT();
+Test_WRITE_PROTECTED_LREAL();
+Test_WRITE_PROTECTED_REAL();
+Test_WRITE_PROTECTED_SINT();
+Test_WRITE_PROTECTED_STRING();
+Test_WRITE_PROTECTED_TIME();
+Test_WRITE_PROTECTED_TIME_OF_DAY();
+Test_WRITE_PROTECTED_UDINT();
+Test_WRITE_PROTECTED_UINT();
+Test_WRITE_PROTECTED_USINT();
+Test_WRITE_PROTECTED_WORD();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_BOOL: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_BOOL');
+
+WRITE_PROTECTED_BOOL(ADR(ProtectedVariables.InputBOOL), TRUE);
+AssertEquals_BOOL(TRUE, ProtectedVariables.InputBOOL, 'Overwriting protected InputBOOL');
+
+WRITE_PROTECTED_BOOL(ADR(ProtectedVariables.VarBOOL), TRUE);
+AssertEquals_BOOL(TRUE, ProtectedVariables.VarBOOL, 'Overwriting protected VarBOOL');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_BYTE: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_BYTE');
+
+WRITE_PROTECTED_BYTE(ADR(ProtectedVariables.InputBYTE), 1);
+AssertEquals_BYTE(1, ProtectedVariables.InputBYTE, 'Overwriting protected InputBYTE');
+
+WRITE_PROTECTED_BYTE(ADR(ProtectedVariables.VarBYTE), 1);
+AssertEquals_BYTE(1, ProtectedVariables.VarBYTE, 'Overwriting protected VarBYTE');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_DATE: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_DATE');
+
+WRITE_PROTECTED_DATE(ADR(ProtectedVariables.InputDATE), D#2000-01-01);
+AssertEquals_DATE(D#2000-01-01, ProtectedVariables.InputDATE, 'Overwriting protected InputDATE');
+
+WRITE_PROTECTED_DATE(ADR(ProtectedVariables.VarDATE), D#2000-01-01);
+AssertEquals_DATE(D#2000-01-01, ProtectedVariables.VarDATE, 'Overwriting protected VarDATE');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_DATE_AND_TIME: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_DATE_AND_TIME');
+
+WRITE_PROTECTED_DATE_AND_TIME(ADR(ProtectedVariables.InputDATE_AND_TIME), DT#2000-01-01-00:00);
+AssertEquals_DATE_AND_TIME(DT#2000-01-01-00:00, ProtectedVariables.InputDATE_AND_TIME, 'Overwriting protected InputDATE_AND_TIME');
+
+WRITE_PROTECTED_DATE_AND_TIME(ADR(ProtectedVariables.VarDATE_AND_TIME), DT#2000-01-01-00:00);
+AssertEquals_DATE_AND_TIME(DT#2000-01-01-00:00, ProtectedVariables.VarDATE_AND_TIME, 'Overwriting protected VarDATE_AND_TIME');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_DINT: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_DINT');
+
+WRITE_PROTECTED_DINT(ADR(ProtectedVariables.InputDINT), 1);
+AssertEquals_DINT(1, ProtectedVariables.InputDINT, 'Overwriting protected InputDINT');
+
+WRITE_PROTECTED_DINT(ADR(ProtectedVariables.VarDINT), 1);
+AssertEquals_DINT(1, ProtectedVariables.VarDINT, 'Overwriting protected VarDINT');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_DWORD: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_DWORD');
+
+WRITE_PROTECTED_DWORD(ADR(ProtectedVariables.InputDWORD), 1);
+AssertEquals_DWORD(1, ProtectedVariables.InputDWORD, 'Overwriting protected InputDWORD');
+
+WRITE_PROTECTED_DWORD(ADR(ProtectedVariables.VarDWORD), 1);
+AssertEquals_DWORD(1, ProtectedVariables.VarDWORD, 'Overwriting protected VarDWORD');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_INT: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_INT');
+
+WRITE_PROTECTED_INT(ADR(ProtectedVariables.InputINT), 1);
+AssertEquals_INT(1, ProtectedVariables.InputINT, 'Overwriting protected InputINT');
+
+WRITE_PROTECTED_INT(ADR(ProtectedVariables.VarINT), 1);
+AssertEquals_INT(1, ProtectedVariables.VarINT, 'Overwriting protected VarINT');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_LREAL: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_LREAL');
+
+WRITE_PROTECTED_LREAL(ADR(ProtectedVariables.InputLREAL), 1);
+AssertEquals_LREAL(1, ProtectedVariables.InputLREAL, 0, 'Overwriting protected InputLREAL');
+
+WRITE_PROTECTED_LREAL(ADR(ProtectedVariables.VarLREAL), 1);
+AssertEquals_LREAL(1, ProtectedVariables.VarLREAL, 0, 'Overwriting protected VarLREAL');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_REAL: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_REAL');
+
+WRITE_PROTECTED_REAL(ADR(ProtectedVariables.InputREAL), 1);
+AssertEquals_REAL(1, ProtectedVariables.InputREAL, 0, 'Overwriting protected InputREAL');
+
+WRITE_PROTECTED_REAL(ADR(ProtectedVariables.VarREAL), 1);
+AssertEquals_REAL(1, ProtectedVariables.VarREAL, 0, 'Overwriting protected VarREAL');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_SINT: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_SINT');
+
+WRITE_PROTECTED_SINT(ADR(ProtectedVariables.InputSINT), 1);
+AssertEquals_SINT(1, ProtectedVariables.InputSINT, 'Overwriting protected InputSINT');
+
+WRITE_PROTECTED_SINT(ADR(ProtectedVariables.VarSINT), 1);
+AssertEquals_SINT(1, ProtectedVariables.VarSINT, 'Overwriting protected VarSINT');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_STRING: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_STRING');
+
+WRITE_PROTECTED_STRING(ADR(ProtectedVariables.InputSTRING), 'words');
+AssertEquals_STRING('words', ProtectedVariables.InputSTRING, 'Overwriting protected InputSTRING');
+
+WRITE_PROTECTED_STRING(ADR(ProtectedVariables.VarSTRING), 'words');
+AssertEquals_STRING('words', ProtectedVariables.VarSTRING, 'Overwriting protected VarSTRING');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_TIME: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_TIME');
+
+WRITE_PROTECTED_TIME(ADR(ProtectedVariables.InputTIME), T#1S);
+AssertEquals_TIME(T#1S, ProtectedVariables.InputTIME, 'Overwriting protected InputTIME');
+
+WRITE_PROTECTED_TIME(ADR(ProtectedVariables.VarTIME), T#1S);
+AssertEquals_TIME(T#1S, ProtectedVariables.VarTIME, 'Overwriting protected VarTIME');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_TIME_OF_DAY: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_TIME_OF_DAY');
+
+WRITE_PROTECTED_TIME_OF_DAY(ADR(ProtectedVariables.InputTIME_OF_DAY), TOD#11:11);
+AssertEquals_TIME_OF_DAY(TOD#11:11, ProtectedVariables.InputTIME_OF_DAY, 'Overwriting protected InputTIME_OF_DAY');
+
+WRITE_PROTECTED_TIME_OF_DAY(ADR(ProtectedVariables.VarTIME_OF_DAY), TOD#11:11);
+AssertEquals_TIME_OF_DAY(TOD#11:11, ProtectedVariables.VarTIME_OF_DAY, 'Overwriting protected VarTIME_OF_DAY');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_UDINT: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_UDINT');
+
+WRITE_PROTECTED_UDINT(ADR(ProtectedVariables.InputUDINT), 1);
+AssertEquals_UDINT(1, ProtectedVariables.InputUDINT, 'Overwriting protected InputUDINT');
+
+WRITE_PROTECTED_UDINT(ADR(ProtectedVariables.VarUDINT), 1);
+AssertEquals_UDINT(1, ProtectedVariables.VarUDINT, 'Overwriting protected VarUDINT');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_UINT: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_UINT');
+
+WRITE_PROTECTED_UINT(ADR(ProtectedVariables.InputUINT), 1);
+AssertEquals_UINT(1, ProtectedVariables.InputUINT, 'Overwriting protected InputUINT');
+
+WRITE_PROTECTED_UINT(ADR(ProtectedVariables.VarUINT), 1);
+AssertEquals_UINT(1, ProtectedVariables.VarUINT, 'Overwriting protected VarUINT');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_USINT: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_USINT');
+
+WRITE_PROTECTED_USINT(ADR(ProtectedVariables.InputUSINT), 1);
+AssertEquals_USINT(1, ProtectedVariables.InputUSINT, 'Overwriting protected InputUSINT');
+
+WRITE_PROTECTED_USINT(ADR(ProtectedVariables.VarUSINT), 1);
+AssertEquals_USINT(1, ProtectedVariables.VarUSINT, 'Overwriting protected VarUSINT');
+
+TEST_FINISHED();
+~~~
+---
+~~~ST
+METHOD Test_WRITE_PROTECTED_WORD: 
+VAR
+    ProtectedVariables: FB_ProtectedVariables;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_WRITE_PROTECTED_WORD');
+
+WRITE_PROTECTED_WORD(ADR(ProtectedVariables.InputWORD), 1);
+AssertEquals_WORD(1, ProtectedVariables.InputWORD, 'Overwriting protected InputWORD');
+
+WRITE_PROTECTED_WORD(ADR(ProtectedVariables.VarWORD), 1);
+AssertEquals_WORD(1, ProtectedVariables.VarWORD, 'Overwriting protected VarWORD');
+
+TEST_FINISHED();
+~~~
+---
+
+                    
+    This FB tests the free function TEST_FINISHED_NAMED. Calling this function with a name that doesn't exist should
+    produce an error message that says so. This error message should also only be printed once.
+
+
+~~~ST
+FUNCTION_BLOCK FB_TestFinishedNamedDoesNotExist EXTENDS CfUnit.FB_TestSuite
+
+~~~
+~~~ST
+Test_FinishedNamed();
+~~~
+---
+~~~ST
+METHOD Test_FinishedNamed: 
+VAR
+    a: INT;
+    b: INT;
+    bajs: BOOL;
+END_VAR
+
+~~~
+~~~ST
+TEST('Test_FinishedNamed');
+
+AssertEquals_INT(Expected := a,
+                 Actual := b,
+                 Message := 'Values differ');
+
+TEST_FINISHED_NAMED('AnotherTestNameThatDoesNotExist');
+~~~
+---
+~~~ST
+PROGRAM PRG_TEST
+VAR
+    PrimitiveTypes: FB_PrimitiveTypes;
+    AssertTrueFalse: FB_AssertTrueFalse;
+    AssertEveryFailedTestTwice: FB_AssertEveryFailedTestTwice;
+    CreateFourTestsWithSameName: FB_CreateFourTestsWithSameName;
+    ArrayPrimitiveTypes: FB_ArrayPrimitiveTypes;
+    CreateDisabledTest: FB_CreateDisabledTest;
+    AnyPrimitiveTypes: FB_AnyPrimitiveTypes;
+    AssertEveryFailedTestTwiceArrayVersion: FB_AssertEveryFailedTestTwiceArrayVersion;
+    AnyToUnionValue: FB_AnyToUnionValue;
+    MultipleAssertWithSameParametersInSameCycleWithSameTest: FB_MultipleAssertWithSameParametersInSameCycleWithSameTest;
+    MultipleAssertWithSameParametersInDifferentCyclesButWithDifferentTests: FB_MultipleAssertWithSameParametersInDifferentCyclesButWithDifferentTests;
+    MultipleAssertWithSameParametersInDifferentCyclesAndInSameTest: FB_MultipleAssertWithSameParametersInDifferentCyclesAndInSameTest;
+    AdjustAssertFailureMessageToMax252CharLengthTest: FB_AdjustAssertFailureMessageToMax252CharLengthTest;
+    EmptyTestSuite: FB_EmptyTestSuite;
+    CheckIfSpecificTestIsFinished: FB_CheckIfSpecificTestIsFinished;
+    WriteProtectedFunctions: FB_WriteProtectedFunctions;
+    TestFinishedNamed: FB_TestFinishedNamed;
+END_VAR
+
+~~~
+~~~ST
+CfUnit.RUN();
+~~~