FB_ArrayPrimitiveTypes Function Block

Extends TcUnit.FB_TestSuite

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

Methods

Test_BOOL_Array_DifferInContent PRIVATE

Implementation

TEST('Test_BOOL_Array_DifferInContent');

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

TEST_FINISHED();

Test_BOOL_Array_DifferInSize PRIVATE

Implementation

TEST('Test_BOOL_Array_DifferInSize');

TCUNIT_ADSLOGSTR(msgCtrlMask := ADSLOG_MSGTYPE_HINT,
                 msgFmtStr := 'This is just a string %s',
                 strArg := '8');

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

TEST_FINISHED();

Test_BOOL_Array_Equals PRIVATE

Implementation

TEST('Test_BOOL_Array_Equals');

TCUNIT_ADSLOGSTR(msgCtrlMask := ADSLOG_MSGTYPE_HINT,
                 msgFmtStr := 'This is just a string %s',
                 strArg := '7');

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

TEST_FINISHED();

Test_BYTE_Array_DifferInContent PRIVATE

Implementation

TEST('Test_BYTE_Array_DifferInContent');

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

TEST_FINISHED();

Test_BYTE_Array_DifferInSize PRIVATE

Implementation

TEST('Test_BYTE_Array_DifferInSize');

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

TEST_FINISHED();

Test_BYTE_Array_Equals PRIVATE

Implementation

TEST('Test_BYTE_Array_Equals');

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

TEST_FINISHED();

Test_DINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_DINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_DINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_DINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_DINT_Array_Equals PRIVATE

Implementation

TEST('Test_DINT_Array_Equals');

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

TEST_FINISHED();

Test_DWORD_Array_DifferInContent PRIVATE

Implementation

TEST('Test_DWORD_Array_DifferInContent');

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

TEST_FINISHED();

Test_DWORD_Array_DifferInSize PRIVATE

Implementation

TEST('Test_DWORD_Array_DifferInSize');

TCUNIT_ADSLOGSTR(msgCtrlMask := ADSLOG_MSGTYPE_ERROR,
                 msgFmtStr := 'This is just a string %s',
                 strArg := '10');

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

TEST_FINISHED();

Test_DWORD_Array_Equals PRIVATE

Implementation

TEST('Test_DWORD_Array_Equals');

TCUNIT_ADSLOGSTR(msgCtrlMask := ADSLOG_MSGTYPE_ERROR,
                 msgFmtStr := 'This is just a string %s',
                 strArg := '9');

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

TEST_FINISHED();

Test_INT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_INT_Array_DifferInContent');

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

TEST_FINISHED();

Test_INT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_INT_Array_DifferInSize');

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

TEST_FINISHED();

Test_INT_Array_Equals PRIVATE

Implementation

TEST('Test_INT_Array_Equals');

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

TEST_FINISHED();

Test_LINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_LINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_LINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_LINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_LINT_Array_Equals PRIVATE

Implementation

TEST('Test_LINT_Array_Equals');

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

TEST_FINISHED();

Test_LREAL_Array_DifferInContent PRIVATE

Implementation

TEST('Test_LREAL_Array_DifferInContent');

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

TEST_FINISHED();

Test_LREAL_Array_DifferInSize PRIVATE

Implementation

TEST('Test_LREAL_Array_DifferInSize');

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

TEST_FINISHED();

Test_LREAL_Array_Equals PRIVATE

Implementation

TEST('Test_LREAL_Array_Equals');

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

TEST_FINISHED();

Test_LREAL_Array2d_DifferInContent_LBOUND PRIVATE

Implementation

TEST('Test_LREAL_Array2d_DifferInContent_LBOUND');

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

TEST_FINISHED();

Test_LREAL_Array2d_DifferInContent_Middle PRIVATE

Implementation

TEST('Test_LREAL_Array2d_DifferInContent_Middle');

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

TEST_FINISHED();

Test_LREAL_Array2d_DifferInContent_UBOUND PRIVATE

Implementation

TEST('Test_LREAL_Array2d_DifferInContent_UBOUND');

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

TEST_FINISHED();

Test_LREAL_Array2d_DifferInSize_D1 PRIVATE

Validate assertion for size difference in first dimension of 2d array

Implementation

TEST('Test_LREAL_Array2d_DifferInSize_D1');

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

TEST_FINISHED();

Test_LREAL_Array2d_DifferInSize_D2 PRIVATE

Validate assertion for size difference in second dimension of 2d array

Implementation

TEST('Test_LREAL_Array2d_DifferInSize_D2');

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

TEST_FINISHED();

Test_LREAL_Array2d_Equals PRIVATE

Implementation

TEST('Test_LREAL_Array2d_Equals');

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

TEST_FINISHED();

Test_LREAL_Array3d_DifferInContent_LBOUND PRIVATE

Implementation

TEST('Test_LREAL_Array3d_DifferInContent_LBOUND');

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

TEST_FINISHED();

Test_LREAL_Array3d_DifferInContent_Middle PRIVATE

Implementation

TEST('Test_LREAL_Array3d_DifferInContent_Middle');

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

TEST_FINISHED();

Test_LREAL_Array3d_DifferInContent_UBOUND PRIVATE

Implementation

TEST('Test_LREAL_Array3d_DifferInContent_UBOUND');

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

TEST_FINISHED();

Test_LREAL_Array3d_DifferInSize_D1 PRIVATE

Validate assertion for size difference in first dimension of 3d array

Implementation

TEST('Test_LREAL_Array3d_DifferInSize_D1');

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

TEST_FINISHED();

Test_LREAL_Array3d_DifferInSize_D2 PRIVATE

Validate assertion for size difference in second dimension of 3d array

Implementation

TEST('Test_LREAL_Array3d_DifferInSize_D2');

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

TEST_FINISHED();

Test_LREAL_Array3d_DifferInSize_D3 PRIVATE

Validate assertion for size difference in third dimension of 3d array

Implementation

TEST('Test_LREAL_Array3d_DifferInSize_D3');

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

TEST_FINISHED();

Test_LREAL_Array3d_Equals PRIVATE

Implementation

TEST('Test_LREAL_Array3d_Equals');

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

TEST_FINISHED();

Test_LWORD_Array_DifferInContent PRIVATE

Implementation

TEST('Test_LWORD_Array_DifferInContent');

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

TEST_FINISHED();

Test_LWORD_Array_DifferInSize PRIVATE

Implementation

TEST('Test_LWORD_Array_DifferInSize');

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

TEST_FINISHED();

Test_LWORD_Array_Equals PRIVATE

Implementation

TEST('Test_LWORD_Array_Equals');

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

TEST_FINISHED();

Test_REAL_Array_DifferInContent PRIVATE

Implementation

TEST('Test_REAL_Array_DifferInContent');

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

TEST_FINISHED();

Test_REAL_Array_DifferInSize PRIVATE

Implementation

TEST('Test_REAL_Array_DifferInSize');

TCUNIT_ADSLOGSTR(msgCtrlMask := ADSLOG_MSGTYPE_WARN,
                 msgFmtStr := 'This is just a string %s',
                 strArg := '12');

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

TEST_FINISHED();

Test_REAL_Array_Equals PRIVATE

Implementation

TEST('Test_REAL_Array_Equals');

TCUNIT_ADSLOGSTR(msgCtrlMask := ADSLOG_MSGTYPE_WARN,
                 msgFmtStr := 'This is just a string %s',
                 strArg := '11');

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

TEST_FINISHED();

Test_REAL_Array2d_DifferInContent_LBOUND PRIVATE

Implementation

TEST('Test_REAL_Array2d_DifferInContent_LBOUND');

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

TEST_FINISHED();

Test_REAL_Array2d_DifferInContent_Middle PRIVATE

Implementation

TEST('Test_REAL_Array2d_DifferInContent_Middle');

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

TEST_FINISHED();

Test_REAL_Array2d_DifferInContent_UBOUND PRIVATE

Implementation

TEST('Test_REAL_Array2d_DifferInContent_UBOUND');

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

TEST_FINISHED();

Test_REAL_Array2d_DifferInSize_D1 PRIVATE

Validate assertion for size difference in first dimension of 2d array

Implementation

TEST('Test_REAL_Array2d_DifferInSize_D1');

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

TEST_FINISHED();

Test_REAL_Array2d_DifferInSize_D2 PRIVATE

Validate assertion for size difference in second dimension of 2d array

Implementation

TEST('Test_REAL_Array2d_DifferInSize_D2');

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

TEST_FINISHED();

Test_REAL_Array2d_Equals PRIVATE

Implementation

TEST('Test_REAL_Array2d_Equals');

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

TEST_FINISHED();

Test_REAL_Array3d_DifferInContent_LBOUND PRIVATE

Implementation

TEST('Test_REAL_Array3d_DifferInContent_LBOUND');

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

TEST_FINISHED();

Test_REAL_Array3d_DifferInContent_Middle PRIVATE

Implementation

TEST('Test_REAL_Array3d_DifferInContent_Middle');

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

TEST_FINISHED();

Test_REAL_Array3d_DifferInContent_UBOUND PRIVATE

Implementation

TEST('Test_REAL_Array3d_DifferInContent_UBOUND');

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

TEST_FINISHED();

Test_REAL_Array3d_DifferInSize_D1 PRIVATE

Validate assertion for size difference in first dimension of 3d array

Implementation

TEST('Test_REAL_Array3d_DifferInSize_D1');

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

TEST_FINISHED();

Test_REAL_Array3d_DifferInSize_D2 PRIVATE

Validate assertion for size difference in second dimension of 3d array

Implementation

TEST('Test_REAL_Array3d_DifferInSize_D2');

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

TEST_FINISHED();

Test_REAL_Array3d_DifferInSize_D3 PRIVATE

Validate assertion for size difference in third dimension of 3d array

Implementation

TEST('Test_REAL_Array3d_DifferInSize_D3');

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

TEST_FINISHED();

Test_REAL_Array3d_Equals PRIVATE

Implementation

TEST('Test_REAL_Array3d_Equals');

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

TEST_FINISHED();

Test_SINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_SINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_SINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_SINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_SINT_Array_Equals PRIVATE

Implementation

TEST('Test_SINT_Array_Equals');

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

TEST_FINISHED();

Test_UDINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_UDINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_UDINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_UDINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_UDINT_Array_Equals PRIVATE

Implementation

TEST('Test_UDINT_Array_Equals');

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

TEST_FINISHED();

Test_UINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_UINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_UINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_UINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_UINT_Array_Equals PRIVATE

Implementation

TEST('Test_UINT_Array_Equals');

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

TEST_FINISHED();

Test_ULINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_ULINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_ULINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_ULINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_ULINT_Array_Equals PRIVATE

Implementation

TEST('Test_ULINT_Array_Equals');

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

TEST_FINISHED();

Test_USINT_Array_DifferInContent PRIVATE

Implementation

TEST('Test_USINT_Array_DifferInContent');

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

TEST_FINISHED();

Test_USINT_Array_DifferInSize PRIVATE

Implementation

TEST('Test_USINT_Array_DifferInSize');

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

TEST_FINISHED();

Test_USINT_Array_Equals PRIVATE

Implementation

TEST('Test_USINT_Array_Equals');

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

TEST_FINISHED();

Test_WORD_Array_DifferInContent PRIVATE

Implementation

TEST('Test_WORD_Array_DifferInContent');

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

TEST_FINISHED();

Test_WORD_Array_DifferInSize PRIVATE

Implementation

TEST('Test_WORD_Array_DifferInSize');

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

TEST_FINISHED();

Test_WORD_Array_Equals PRIVATE

Implementation

TEST('Test_WORD_Array_Equals');

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

TEST_FINISHED();

Used by

PRG_TEST

Declaration source

(*
    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 TcUnit.FB_TestSuite