co♻e: unittest framework for CODESYS

                 This testsuite tests the function block FB_AdjustAssertFailureMessageToMax255CharLength_Test

FUNCTION_BLOCK FB_AdjustAssertFailureMessageToMax252CharLengthTest EXTENDS CfUnit.FB_TestSuite

TestInstancePath252CharsExpectTooLongTestInstancePath();
TestInstancePath220CharsExpectShortenedTestInstancePath();
TestInstancePath255CharsExpectTooLongTestInstancePath();

METHOD TestInstancePath220CharsExpectShortenedTestInstancePath: 
VAR
    AdjustAssertFailureMessageToMax252CharLength: FB_AdjustAssertFailureMessageToMax252CharLength;
    TestInstancePathNameWith220Chars: T_MaxString;
    TooLongTestMessage60Chars: T_MaxString;
    TestMessageResultExpected: T_MaxString;
    TestInstancePathResult: T_MaxString;
    TestMessageResult: T_MaxString;
END_VAR

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();

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

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();

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

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.

FUNCTION_BLOCK FB_AnyPrimitiveTypes EXTENDS CfUnit.FB_TestSuite

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();

METHOD Test_ANY_BOOL_Differ: 
VAR
    a: BOOL;
    b: BOOL;
END_VAR

TEST('Test_ANY_BOOL_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_BOOL_Equals: 
VAR
    a: BOOL;
    b: BOOL;
END_VAR

TEST('Test_ANY_BOOL_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_BYTE_Differ: 
VAR
    a: BYTE;
    b: BYTE;
END_VAR

TEST('Test_ANY_BYTE_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_BYTE_Equals: 
VAR
    a: BYTE;
    b: BYTE;
END_VAR

TEST('Test_ANY_BYTE_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DATE_AND_TIME_Differ: 
VAR
    a: DT;
    b: DT;
END_VAR

TEST('Test_ANY_DATE_AND_TIME_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DATE_AND_TIME_Equals: 
VAR
    a: DT;
    b: DT;
END_VAR

TEST('Test_ANY_DATE_AND_TIME_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DATE_Differ: 
VAR
    a: DATE;
    b: DATE;
END_VAR

TEST('Test_ANY_DATE_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DATE_Equals: 
VAR
    a: DATE;
    b: DATE;
END_VAR

TEST('Test_ANY_DATE_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DINT_Differ: 
VAR
    a: DINT;
    b: DINT;
END_VAR

TEST('Test_ANY_DINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DINT_Equals: 
VAR
    a: DINT;
    b: DINT;
END_VAR

TEST('Test_ANY_DINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DWORD_Differ: 
VAR
    a: DWORD;
    b: DWORD;
END_VAR

TEST('Test_ANY_DWORD_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_DWORD_Equals: 
VAR
    a: DWORD;
    b: DWORD;
END_VAR

TEST('Test_ANY_DWORD_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_INT_Differ: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('Test_ANY_INT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_INT_Equals: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('Test_ANY_INT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LINT_Differ: 
VAR
    a: LINT;
    b: LINT;
END_VAR

TEST('Test_ANY_LINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LINT_Equals: 
VAR
    a: LINT;
    b: LINT;
END_VAR

TEST('Test_ANY_LINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LREAL_Differ: 
VAR
    a: LREAL;
    b: LREAL;
END_VAR

TEST('Test_ANY_LREAL_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LREAL_Equals: 
VAR
    a: LREAL;
    b: LREAL;
END_VAR

TEST('Test_ANY_LREAL_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LTIME_Differ: 
VAR
    a: LTIME;
    b: LTIME;
END_VAR

TEST('Test_ANY_LTIME_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LTIME_Equals: 
VAR
    a: LTIME;
    b: LTIME;
END_VAR

TEST('Test_ANY_LTIME_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LWORD_Differ: 
VAR
    a: LWORD;
    b: LWORD;
END_VAR

TEST('Test_ANY_LWORD_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_LWORD_Equals: 
VAR
    a: LWORD;
    b: LWORD;
END_VAR

TEST('Test_ANY_LWORD_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_REAL_Differ: 
VAR
    a: REAL;
    b: REAL;
END_VAR

TEST('Test_ANY_REAL_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_REAL_Equals: 
VAR
    a: REAL;
    b: REAL;
END_VAR

TEST('Test_ANY_REAL_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_SINT_Differ: 
VAR
    a: SINT;
    b: SINT;
END_VAR

TEST('Test_ANY_SINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_SINT_Equals: 
VAR
    a: SINT;
    b: SINT;
END_VAR

TEST('Test_ANY_SINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_STRING_Differ: 
VAR
    a: string;
    b: string;
END_VAR

TEST('Test_ANY_STRING_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_STRING_Equals: 
VAR
    a: string;
    b: string;
END_VAR

TEST('Test_ANY_STRING_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_TIME_Differ: 
VAR
    a: TIME;
    b: TIME;
END_VAR

TEST('Test_ANY_TIME_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_TIME_Equals: 
VAR
    a: TIME;
    b: TIME;
END_VAR

TEST('Test_ANY_TIME_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_TIME_OF_DAY_Differ: 
VAR
    a: TOD;
    b: TOD;
END_VAR

TEST('Test_ANY_TIME_OF_DAY_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_TIME_OF_DAY_Equals: 
VAR
    a: TOD;
    b: TOD;
END_VAR

TEST('Test_ANY_TIME_OF_DAY_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_UDINT_Differ: 
VAR
    a: UDINT;
    b: UDINT;
END_VAR

TEST('Test_ANY_UDINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_UDINT_Equals: 
VAR
    a: UDINT;
    b: UDINT;
END_VAR

TEST('Test_ANY_UDINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_UINT_Differ: 
VAR
    a: UINT;
    b: UINT;
END_VAR

TEST('Test_ANY_UINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_UINT_Equals: 
VAR
    a: UINT;
    b: UINT;
END_VAR

TEST('Test_ANY_UINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_ULINT_Differ: 
VAR
    a: ULINT;
    b: ULINT;
END_VAR

TEST('Test_ANY_ULINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_ULINT_Equals: 
VAR
    a: ULINT;
    b: ULINT;
END_VAR

TEST('Test_ANY_ULINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_USINT_Differ: 
VAR
    a: USINT;
    b: USINT;
END_VAR

TEST('Test_ANY_USINT_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_USINT_Equals: 
VAR
    a: USINT;
    b: USINT;
END_VAR

TEST('Test_ANY_USINT_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_WORD_Differ: 
VAR
    a: WORD;
    b: WORD;
END_VAR

TEST('Test_ANY_WORD_Differ');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ANY_WORD_Equals: 
VAR
    a: WORD;
    b: WORD;
END_VAR

TEST('Test_ANY_WORD_Equals');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'Values differ');

TEST_FINISHED();

Tests the free function F_AnyToUnionValue.

FUNCTION_BLOCK FB_AnyToUnionValue EXTENDS CfUnit.FB_TestSuite
VAR
    aBit: BIT;
END_VAR

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();

METHOD Test_BIT: 
VAR
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_BIT');

result := CfUnit.F_AnyToUnionValue(AnyValue := aBit);

AssertEquals(Expected := aBit,
             Actual := result.bitExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_BOOL: 
VAR
    a: BOOL;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_BOOL');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.boolExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_BYTE: 
VAR
    a: BYTE;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_BYTE');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.byteExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_DATE: 
VAR
    a: DATE;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_DATE');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.dateExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_DATE_AND_TIME: 
VAR
    a: DT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_DATE_AND_TIME');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.dateandtimeExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_DINT: 
VAR
    a: DINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_DINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.dintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_DWORD: 
VAR
    a: DWORD;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_DWORD');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.dwordExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_INT: 
VAR
    a: INT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_INT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.intExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_LINT: 
VAR
    a: LINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_LINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.lintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_LREAL: 
VAR
    a: LREAL;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_LREAL');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.lrealExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_LTIME: 
VAR
    a: LTIME;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_LTIME');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.ltimeExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_LWORD: 
VAR
    a: LWORD;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_LWORD');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.lwordExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_REAL: 
VAR
    a: REAL;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_REAL');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.realExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_SINT: 
VAR
    a: SINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_SINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.sintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_STRING: 
VAR
    a: string;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_STRING');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.stringExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_STRING_2: 
VAR
    a: T_MaxString;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_STRING_2');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.stringExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_TIME: 
VAR
    a: TIME;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_TIME');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.timeExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_TIME_OF_DAY: 
VAR
    a: TOD;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_TIME_OF_DAY');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.timeofdayExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_UDINT: 
VAR
    a: UDINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_UDINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.udintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_UINT: 
VAR
    a: UINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_UINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.uintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_ULINT: 
VAR
    a: ULINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('TEST_ULINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.ulintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_USINT: 
VAR
    a: USINT;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_USINT');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.usintExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_WORD: 
VAR
    a: WORD;
    result: U_ExpectedOrActual;
END_VAR

TEST('Test_WORD');

result := CfUnit.F_AnyToUnionValue(AnyValue := a);

AssertEquals(Expected := a,
             Actual := result.wordExpectedOrActual,
             Message := 'Values differ');

TEST_FINISHED();

METHOD Test_WSTRING: 
VAR
    a: wstring;
    result: U_ExpectedOrActual;
END_VAR

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

FUNCTION_BLOCK FB_ArrayPrimitiveTypes EXTENDS CfUnit.FB_TestSuite

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();

METHOD Test_BOOL_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_BOOL_Array_DifferInContent');

AssertArrayEquals_BOOL(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_BOOL_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_BOOL_Array_DifferInSize');

AssertArrayEquals_BOOL(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_BOOL_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_BOOL_Array_Equals');

AssertArrayEquals_BOOL(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_BYTE_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_BYTE_Array_DifferInContent');

AssertArrayEquals_BYTE(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_BYTE_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_BYTE_Array_DifferInSize');

AssertArrayEquals_BYTE(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_BYTE_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_BYTE_Array_Equals');

AssertArrayEquals_BYTE(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_DINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_DINT_Array_DifferInContent');

AssertArrayEquals_DINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_DINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_DINT_Array_DifferInSize');

AssertArrayEquals_DINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_DINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_DINT_Array_Equals');

AssertArrayEquals_DINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_DWORD_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_DWORD_Array_DifferInContent');

AssertArrayEquals_DWORD(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_DWORD_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_DWORD_Array_DifferInSize');

AssertArrayEquals_DWORD(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_DWORD_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_DWORD_Array_Equals');

AssertArrayEquals_DWORD(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_INT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_INT_Array_DifferInContent');

AssertArrayEquals_INT(Expecteds := a,
                      Actuals := b,
                      Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_INT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_INT_Array_DifferInSize');

AssertArrayEquals_INT(Expecteds := a,
                      Actuals := b,
                      Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_INT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_INT_Array_Equals');

AssertArrayEquals_INT(Expecteds := a,
                      Actuals := b,
                      Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LINT_Array_DifferInContent');

AssertArrayEquals_LINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LINT_Array_DifferInSize');

AssertArrayEquals_LINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LINT_Array_Equals');

AssertArrayEquals_LINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array_DifferInContent');

AssertArrayEquals_LREAL(Expecteds := a,
                        Actuals := b,
                        Delta := 0.01,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array_DifferInSize');

AssertArrayEquals_LREAL(Expecteds := a,
                        Actuals := b,
                        Delta := 0.01,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array_Equals');

AssertArrayEquals_LREAL(Expecteds := a,
                        Actuals := b,
                        Delta := 0.01,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array2d_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array2d_DifferInContent');

AssertArray2dEquals_LREAL(Expecteds := a,
                          Actuals := b,
                          Delta := 0.01,
                          Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array2d_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array2d_DifferInSize');

AssertArray2dEquals_LREAL(Expecteds := a,
                          Actuals := b,
                          Delta := 0.01,
                          Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array2d_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array2d_Equals');

AssertArray2dEquals_LREAL(Expecteds := a,
                          Actuals := b,
                          Delta := 0.01,
                          Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array3d_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array3d_DifferInContent');

AssertArray3dEquals_LREAL(Expecteds := a,
                          Actuals := b,
                          Delta := 0.01,
                          Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array3d_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array3d_DifferInSize');

AssertArray3dEquals_LREAL(Expecteds := a,
                          Actuals := b,
                          Delta := 0.01,
                          Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LREAL_Array3d_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LREAL_Array3d_Equals');

AssertArray3dEquals_LREAL(Expecteds := a,
                          Actuals := b,
                          Delta := 0.01,
                          Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LWORD_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LWORD_Array_DifferInContent');

AssertArrayEquals_LWORD(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LWORD_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LWORD_Array_DifferInSize');

AssertArrayEquals_LWORD(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_LWORD_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_LWORD_Array_Equals');

AssertArrayEquals_LWORD(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array_DifferInContent');

AssertArrayEquals_REAL(Expecteds := a,
                       Actuals := b,
                       Delta := 0.01,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array_DifferInSize');

AssertArrayEquals_REAL(Expecteds := a,
                       Actuals := b,
                       Delta := 0.01,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array_Equals');

AssertArrayEquals_REAL(Expecteds := a,
                       Actuals := b,
                       Delta := 0.01,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array2d_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array2d_DifferInContent');

AssertArray2dEquals_REAL(Expecteds := a,
                         Actuals := b,
                         Delta := 0.01,
                         Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array2d_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array2d_DifferInSize');

AssertArray2dEquals_REAL(Expecteds := a,
                         Actuals := b,
                         Delta := 0.01,
                         Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array2d_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array2d_Equals');

AssertArray2dEquals_REAL(Expecteds := a,
                         Actuals := b,
                         Delta := 0.01,
                         Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array3d_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array3d_DifferInContent');

AssertArray3dEquals_REAL(Expecteds := a,
                         Actuals := b,
                         Delta := 0.01,
                         Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array3d_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array3d_DifferInSize');

AssertArray3dEquals_REAL(Expecteds := a,
                         Actuals := b,
                         Delta := 0.01,
                         Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_REAL_Array3d_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_REAL_Array3d_Equals');

AssertArray3dEquals_REAL(Expecteds := a,
                         Actuals := b,
                         Delta := 0.01,
                         Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_SINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_SINT_Array_DifferInContent');

AssertArrayEquals_SINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_SINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_SINT_Array_DifferInSize');

AssertArrayEquals_SINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_SINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_SINT_Array_Equals');

AssertArrayEquals_SINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_UDINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_UDINT_Array_DifferInContent');

AssertArrayEquals_UDINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_UDINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_UDINT_Array_DifferInSize');

AssertArrayEquals_UDINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_UDINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_UDINT_Array_Equals');

AssertArrayEquals_UDINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_UINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_UINT_Array_DifferInContent');

AssertArrayEquals_UINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_UINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_UINT_Array_DifferInSize');

AssertArrayEquals_UINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_UINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_UINT_Array_Equals');

AssertArrayEquals_UINT(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_ULINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_ULINT_Array_DifferInContent');

AssertArrayEquals_ULINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_ULINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_ULINT_Array_DifferInSize');

AssertArrayEquals_ULINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_ULINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_ULINT_Array_Equals');

AssertArrayEquals_ULINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_USINT_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_USINT_Array_DifferInContent');

AssertArrayEquals_USINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_USINT_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_USINT_Array_DifferInSize');

AssertArrayEquals_USINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_USINT_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_USINT_Array_Equals');

AssertArrayEquals_USINT(Expecteds := a,
                        Actuals := b,
                        Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_WORD_Array_DifferInContent: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_WORD_Array_DifferInContent');

AssertArrayEquals_WORD(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_WORD_Array_DifferInSize: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

TEST('Test_WORD_Array_DifferInSize');

AssertArrayEquals_WORD(Expecteds := a,
                       Actuals := b,
                       Message := 'Arrays differ');

TEST_FINISHED();

METHOD Test_WORD_Array_Equals: 
VAR
    a: ARRAY [..] OF ;
    b: ARRAY [..] OF ;
END_VAR

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.

FUNCTION_BLOCK FB_AssertEveryFailedTestTwice EXTENDS CfUnit.FB_TestSuite
VAR
    AssertCount: USINT;
END_VAR

TwiceAssertCall();

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

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.

FUNCTION_BLOCK FB_AssertEveryFailedTestTwiceArrayVersion EXTENDS CfUnit.FB_TestSuite
VAR
    AssertCount: USINT;
END_VAR

TwiceAssertCall_Arrays();

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

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.

FUNCTION_BLOCK FB_AssertTrueFalse EXTENDS CfUnit.FB_TestSuite

AssertThatINTsAreEqual();
AssertThatINTsAreNotEqual();
AssertThatWORDsAreEqual();
AssertThatWORDsAreNotEqual();

METHOD AssertThatINTsAreEqual: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('AssertThatINTsAreEqual');

AssertFalse(Condition := (a <> b),
            Message := 'INTs are equal');

TEST_FINISHED();

METHOD AssertThatINTsAreNotEqual: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('AssertThatINTsAreNotEqual');

AssertFalse(Condition := (a = b),
            Message := 'INTs are equal');

TEST_FINISHED();

METHOD AssertThatWORDsAreEqual: 
VAR
    a: WORD;
    b: WORD;
END_VAR

TEST('AssertThatWORDsAreEqual');

AssertTrue(Condition := (a = b),
           Message := 'WORDs are not equal');

TEST_FINISHED();

METHOD AssertThatWORDsAreNotEqual: 
VAR
    a: WORD;
    b: WORD;
END_VAR

TEST('AssertThatWORDsAreNotEqual');

AssertTrue(Condition := (a <> b),
           Message := 'WORDs are equal');

TEST_FINISHED();

Verifies that the function IS_TEST_FINISHED('Name') works as intended.

FUNCTION_BLOCK FB_CheckIfSpecificTestIsFinished EXTENDS CfUnit.FB_TestSuite

CheckBeforeAndAfterFinishing();

METHOD CheckBeforeAndAfterFinishing: 

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).

FUNCTION_BLOCK FB_CreateDisabledTest EXTENDS CfUnit.FB_TestSuite

TestEnabled();
TestDisabled();

METHOD TestDisabled: 
VAR
    a: BOOL;
    b: BOOL;
END_VAR

TEST('DISABLED_ThisShouldNotExecute');

AssertEquals(Expected := a,
             Actual := b,
             Message := 'A does not equal B');

TEST_FINISHED();

METHOD TestEnabled: 
VAR
    a: BOOL;
    b: BOOL;
END_VAR

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.

FUNCTION_BLOCK FB_CreateFourTestsWithSameName EXTENDS CfUnit.FB_TestSuite

TestOne();
TestOne_Again();
TestOne_AgainAgain();
TestOne_AgainAgainAgain();

METHOD TestOne: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('TestOne');

AssertEquals_INT(Expected := a,
                 Actual := b,
                 Message := 'A does not equal B');

TEST_FINISHED();

METHOD TestOne_Again: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('TestOne');

AssertEquals_INT(Expected := a,
                 Actual := b,
                 Message := 'A does not equal B again');

TEST_FINISHED();

METHOD TestOne_AgainAgain: 
VAR
    a: INT;
    b: INT;
END_VAR

TEST('TestOne');

AssertEquals_INT(Expected := a,
                 Actual := b,
                 Message := 'A does not equal B again');

TEST_FINISHED();

METHOD TestOne_AgainAgainAgain: 
VAR
    a: INT;
    b: INT;
END_VAR

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

FUNCTION_BLOCK FB_EmptyTestSuite EXTENDS CfUnit.FB_TestSuite

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.

FUNCTION_BLOCK FB_MultipleAssertWithSameParametersInDifferentCyclesAndInSameTest EXTENDS CfUnit.FB_TestSuite
VAR
    TimerAgain: TON;
    TimerAgainAgain: TON;
    CalledAll: BOOL;
END_VAR

Assert_SeveralTimes();

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

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.

FUNCTION_BLOCK FB_MultipleAssertWithSameParametersInDifferentCyclesButWithDifferentTests EXTENDS CfUnit.FB_TestSuite
VAR
    TimerAgain: TON;
    TimerAgainAgain: TON;
    CalledAll: BOOL;
END_VAR

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

METHOD Assert_SeveralTimes: 
VAR
    a: DWORD;
    b: DWORD;
    c: DWORD;
    d: DWORD;
    e: DWORD;
    f: DWORD;
END_VAR