Programming Language Support ---------------------------- While HWUT is designed to support any programming language that is able to produce an application that can be executed from the command line and print something on the standard output, HWUT comes with some specific support for several programming languages. This section outlines auxiliaries that may facilitate the implementation of test applications. All language specific support is located in the directory '$HWUT_PATH/support/X' where 'X' is the name of the specific programming language. Choices ....... HWUT's interaction with the test applications is based on command line arguments. HWUT provides a means to check them elegantly using the macro ``hwut_choice``. By means of this macro the following code fragment .. code-block:: c int main(int argc, char** argv) { uint8_t* test_string = 0x0; if( argc > 1 ) if( strcmp(argv[1], "--hwut-info") == 0 ) { printf("My String Function Test\n"); printf("CHOICES: 7bit, 8bit, 16bit, 32bit"); return 0; } elif( strcmp(argv[1], "7bit") == 0 ) { test_string = create_7bit_encoded_example(); } elif( strcmp(argv[1], "8bit") == 0 ) { test_string = create_8bit_encoded_example(); } elif( strcmp(argv[1], "16bit") == 0 ) { test_string = create_16bit_encoded_example(); } elif( strcmp(argv[1], "32bit") == 0 ) { test_string = create_32bit_encoded_example(); } } /* test on 'test_string' */ ... } can be transformed into .. code-block:: c #include "hwut_unit.h" int main(int argc, char** argv) { uint8_t* test_string = 0x0; hwut_info("My String Function Test;\n" "CHOICES: 7bit, 8bit, 16bit, 32bit;"); hwut_choice("7bit", test_string = create_7bit_encoded_example() ); hwut_choice("8bit", test_string = create_8bit_encoded_example() ); hwut_choice("16bit", test_string = create_16bit_encoded_example() ); hwut_choice("32bit", test_string = create_32bit_encoded_example() ); /* test on 'test_string' */ ... } which is at the same time shorter and more readable. The formal syntax of the ``hwut_choice`` macro is .. c:macro:: hwut_choice(CHOICE, STATEMENT) where ``CHOICE`` is the string against which command line argument '1' is checked. ``STATEMENT`` is the statement to be executed if the first argument is equal to ``CHOICE``. and the formal syntax of the ``hwut_info`` macro is .. c:macro:: hwut_info(MESSAGE) where ``MESSAGE`` is the string to be reported as a response to the command line argument ``--hwut-info``. NUnit-Like Testing .................. At the time of this writing there is a pre-dominant tool for unit testing called 'NUnit'. With this tool tests are based on function calls like ``Assert.AreEqual(This, That)``. This is manytimes very inconvenient when doing larger tests on system behavior. For 'real' unit tests that are restricted to single function calls and what they return such tests may be appropriate. HWUT provides a very simple means to support such tests by the ``hwut_verify_verbose`` macro in 'C/C++'. It can be accessed by including .. code-block:: c #include <hwut_unit.h> This macro allows to check for expressions of any complexity in the syntax of C itself. For example: .. code-block:: c hwut_verify_verbose( 1 + 1 == 2 ); hwut_verify_verbose( 1 + 1 == 3 ); results in the output:: test-hwut_unit.c: [OK] 1 + 1 == 2 test-hwut_unit.c:24: [FAIL] 1 + 1 == 3 Note, that the line number is only output when the test fails. This prevents that HWUT's plain comparison fails when only the position of tests changes inside the file. If it is desired to print out a comment along with the test, then the macro ``hwut_verify_verbose`` may be used, e.g. .. code-block:: c hwut_verify_verbose("----------------------------\n" "One plus one is two, or not?\n" 1 + 1 == 2); which results in:: One plus one is two, or not? ---------------------------- test-hwut_unit.c: [OK] 1 + 1 == 2 If it is only required to print out errors, then the silent version `` .. code-block:: c hwut_verify( 1 + 1 == 2 ); hwut_verify( 1 + 1 == 3 ); hwut_averify("------------------------------------\n" "Silent: One plus one is two, or not?" 1 + 1 == 2); hwut_averify("-------------------------------------------\n" "Silent: One plus one is not three, or what?" 1 + 1 == 3); results in the following output, where obviously the successful tests are not printed anymore:: test-hwut_unit.c:24: [FAIL] 1 + 1 == 3 ----------------------------------- One plus one is not three, or what? test-hwut_unit.c: [FAIL] 1 + 1 == 3 The formal specification of the macros for NUnit like testing is .. cmacro:: hwut_verify_verbose(CONDITION) Tests for ``CONDITION`` to me met. Dependent on the result it prints an OK message or a FAIL message on the screen. If it fails, the place where the failure occured is printed on the screen. .. cmacro:: hwut_verify(CONDITION) acts like ``hwut_verify_verbose`` but prints only in case of failure. .. cmacro:: hwut_verify_verbose(ANNOTATION, CONDITION) which is the 'annotated' version of ``hwut_verify_verbose`` that prints the message ``ANNOTATION`` before the condition is checked. .. cmacro:: hwut_averify(ANNOTATION, CONDITION) acts like ``hwut_verify_verbose`` but prints only in case of failure. The explicit test for equal, not equal, greater than, etc. becomes redundant since with the ``hwut_verify_verbose`` macros all kinds of expressions can be tested. The complexity of its conditions is only restricted by the restrictions of the C-language.