zoukankan      html  css  js  c++  java

  • （八）cmockery中的calculator和run_tests函数的注释代码

        所分析的calculator.c和calculator_test.c文件位于 工程中的 cmockery/src/example/ 目录下，是一个相对而言比较全面的样例程序，用到了cmockery项目中的大多数单元测试方法。基本上涵盖了之前所有的样例程序中的用法，还有两组测试是database操作的样例程序没有做分析也不准备去做了。在结束了这一个样例程序的分析之后，大概就可以将整个cmockery程序过了百分之70的样子，接下来就可以将整个项目代码过一遍了。
    calculator.c
    1. #ifdef HAVE_CONFIG_H
    2. #include "config.h"
    3. #endif
    4. #include <assert.h>
    5. #ifdef HAVE_MALLOC_H
    6. #include <malloc.h>
    7. #endif
    8. #include <stdio.h>
    9. #include <stdlib.h>
    10. #include <string.h>
    11. #define UNIT_TESTING 1
    13. // If this is being built for a unit test.
    14. #if UNIT_TESTING
    16. /* Redirect printf to a function in the test application so it's possible to
    17.  * test the standard output. */
    18. #ifdef printf
    19. #undef printf
    20. #endif // printf
    21. #define printf example_test_printf
    23. extern void print_message(const char *format, ...);
    25. extern int example_test_printf(const char *format, ...);
    27. /* Redirect fprintf to a function in the test application so it's possible to
    28.  * test error messages. */
    29. #ifdef fprintf
    30. #undef fprintf
    31. #endif // fprintf
    32. #define fprintf example_test_fprintf
    34. extern int example_test_fprintf(FILE * const file, const char *format, ...);
    36. // Redirect assert to mock_assert() so assertions can be caught by cmockery.
    37. #ifdef assert
    38. #undef assert
    39. #endif // assert
    40. #define assert(expression) 
    41.     mock_assert((int)(expression), #expression, __FILE__, __LINE__)
    42. void mock_assert(const int result, const char* expression, const char *file,
    43.                  const int line);
    45. /* Redirect calloc and free to test_calloc() and test_free() so cmockery can
    46.  * check for memory leaks. */
    47. #ifdef calloc
    48. #undef calloc
    49. #endif // calloc
    50. #define calloc(num, size) _test_calloc(num, size, __FILE__, __LINE__)
    51. #ifdef free
    52. #undef free
    53. #endif // free
    54. #define free(ptr) _test_free(ptr, __FILE__, __LINE__)
    55. void* _test_calloc(const size_t number_of_elements, const size_t size,
    56.                    const char* file, const int line);
    57. void _test_free(void* const ptr, const char* file, const int line);
    59. /* main is defined in the unit test so redefine name of the the main function
    60.  * here. */
    61. #define main example_main
    63. /* All functions in this object need to be exposed to the test application,
    64.  * so redefine static to nothing. */
    65. #define static
    67. #endif // UNIT_TESTING
    70. // A binary arithmetic integer operation (add, subtract etc.)
    71. typedef int (*BinaryOperator)(int a, int b);
    73. // Structure which maps operator strings to functions.
    74. typedef struct OperatorFunction {
    75.     const char* operator;
    76.     BinaryOperator function;
    77. } OperatorFunction;
    80. int add(int a, int b);
    81. int subtract(int a, int b);
    82. int multiply(int a, int b);
    83. int divide(int a, int b);
    85. // Associate operator strings to functions.
    86. static OperatorFunction operator_function_map[] = {
    87.     {"+", add},
    88.     {"-", subtract},
    89.     {"*", multiply},
    90.     {"/", divide},
    91. };
    93. int add(int a, int b) {
    94.     return a + b;
    95. }
    97. int subtract(int a, int b) {
    98.     return a - b;
    99. }
    101. int multiply(int a, int b) {
    102.     return a * b;
    103. }
    105. int divide(int a, int b) {
    106.     assert(b);  // Check for divide by zero.
    107.     return a / b;
    108. }
    110. /* Searches the specified array of operator_functions for the function
    111.  * associated with the specified operator_string.  This function returns the
    112.  * function associated with operator_string if successful, NULL otherwise.
    113.  */
    114.  BinaryOperator find_operator_function_by_string(
    115.         const size_t number_of_operator_functions,
    116.         const OperatorFunction * const operator_functions,
    117.         const char* const operator_string) {
    118.     size_t i;
    119.     assert(!number_of_operator_functions || operator_functions);
    120.     assert(operator_string);
    122.     for (i = 0; i < number_of_operator_functions; i++) {
    123.         const OperatorFunction *const operator_function =
    124.             &operator_functions[i];
    125.         if (strcmp(operator_function->operator, operator_string) == 0) {
    126.             return operator_function->function;
    127.         }
    128.     }
    129.     return NULL;
    130. }
    132. /* Perform a series of binary arithmetic integer operations with no operator
    133.  * precedence.
    134.  *
    135.  * The input expression is specified by arguments which is an array of
    136.  * containing number_of_arguments strings.  Operators invoked by the expression
    137.  * are specified by the array operator_functions containing
    138.  * number_of_operator_functions, OperatorFunction structures.  The value of
    139.  * each binary operation is stored in a pointer returned to intermediate_values
    140.  * which is allocated by malloc().
    141.  *
    142.  * If successful, this function returns the integer result of the operations.
    143.  * If an error occurs while performing the operation error_occurred is set to
    144.  * 1, the operation is aborted and 0 is returned.
    145.  */
    146.  int perform_operation(
    147.         int number_of_arguments, char *arguments[],
    148.         const size_t number_of_operator_functions,
    149.         const OperatorFunction * const operator_functions,
    150.         int * const number_of_intermediate_values,
    151.         int ** const intermediate_values, int * const error_occurred) {
    152.     char *end_of_integer;
    153.     int value;
    154.     unsigned int i;
    155.     assert(!number_of_arguments || arguments);
    156.     assert(!number_of_operator_functions || operator_functions);
    157.     assert(error_occurred);
    158.     assert(number_of_intermediate_values);
    159.     assert(intermediate_values);
    161.     *error_occurred = 0;
    162.     *number_of_intermediate_values = 0;
    163.     *intermediate_values = NULL;
    164.     if (!number_of_arguments)
    165.         return 0;
    167.     // Parse the first value.
    168.     value = (int)strtol(arguments[0], &end_of_integer, 10);
    169.     if (end_of_integer == arguments[0]) {
    170.         // If an error occurred while parsing the integer.
    171.         fprintf(stderr, "Unable to parse integer from argument %s
",
    172.                 arguments[0]);
    173.         *error_occurred = 1;
    174.         return 0;
    175.     }
    177.     // Allocate an array for the output values.
    178.     *intermediate_values = calloc(((number_of_arguments - 1) / 2),
    179.                                   sizeof(**intermediate_values));
    181.     i = 1;
    182.     while (i < number_of_arguments) {
    183.         int other_value;
    184.         const char* const operator_string = arguments[i];
    185.         const BinaryOperator function = find_operator_function_by_string(
    186.             number_of_operator_functions, operator_functions, operator_string);
    187.         int * const intermediate_value =
    188.             &((*intermediate_values)[*number_of_intermediate_values]);
    189.         (*number_of_intermediate_values) ++;
    191.         if (!function) {
    192.             fprintf(stderr, "Unknown operator %s, argument %d
",
    193.                     operator_string, i);
    194.             *error_occurred = 1;
    195.             break;
    196.         }
    197.         i ++;
    199.         if (i == number_of_arguments) {
    200.             fprintf(stderr, "Binary operator %s missing argument
",
    201.                     operator_string);
    202.             *error_occurred = 1;
    203.             break;
    204.         }
    206.         other_value = (int)strtol(arguments[i], &end_of_integer, 10);
    207.         if (end_of_integer == arguments[i]) {
    208.             // If an error occurred while parsing the integer.
    209.             fprintf(stderr, "Unable to parse integer %s of argument %d
",
    210.                     arguments[i], i);
    211.             *error_occurred = 1;
    212.             break;
    213.         }
    214.         i ++;
    216.         // Perform the operation and store the intermediate value.
    217.         *intermediate_value = function(value, other_value);
    218.         value = *intermediate_value;
    219.     }
    220.     if (*error_occurred) {
    221.         free(*intermediate_values);
    222.         *intermediate_values = NULL;
    223.         *number_of_intermediate_values = 0;
    224.         return 0;
    225.     }
    226.     return value;
    227. }
    229. int main(int argc, char *argv[]) {
    230.     int return_value;
    231.     int number_of_intermediate_values;
    232.     int *intermediate_values;
    233.     // Peform the operation.
    234.     const int result = perform_operation(
    235.         argc - 1, &argv[1],
    236.         sizeof(operator_function_map) / sizeof(operator_function_map[0]),
    237.         operator_function_map, &number_of_intermediate_values,
    238.         &intermediate_values, &return_value);
    240.     // If no errors occurred display the result.
    241.     if (!return_value && argc > 1) {
    242.         unsigned int i;
    243.         unsigned int intermediate_value_index = 0;
    244.         printf("%s
", argv[1]);
    245.         for (i = 2; i < argc; i += 2) {
    246.             assert(intermediate_value_index < number_of_intermediate_values);
    247.             printf("  %s %s = %d
", argv[i], argv[i + 1],
    248.                    intermediate_values[intermediate_value_index++]);
    249.         }
    250.         printf("= %d
", result);
    251.     }
    252.     if (intermediate_values) {
    253.         free(intermediate_values);
    254.     }
    256.     return return_value;
    257. }
    这个是calculator.c的源码，里面自带了一个main.c程序。这个文件可以直接编译：gcc calculator.c 然后生成 a.out之后  运行就是： ./a.out 1 + 2 - 3 + 4。我在做测试的时候发现不能很好的支持*号。
    1. // A binary arithmetic integer operation (add, subtract etc.)
    2. typedef int (*BinaryOperator)(int a, int b);
    4. // Structure which maps operator strings to functions.
    5. typedef struct OperatorFunction {
    6.     const char* operator;
    7.     BinaryOperator function;
    8. } OperatorFunction;
    11. int add(int a, int b);
    12. int subtract(int a, int b);
    13. int multiply(int a, int b);
    14. int divide(int a, int b);
    16. // Associate operator strings to functions.
    17. static OperatorFunction operator_function_map[] = {
    18.     {"+", add},
    19.     {"-", subtract},
    20.     {"*", multiply},
    21.     {"/", divide},
    22. };
    24. int add(int a, int b) {
    25.     return a + b;
    26. }
    28. int subtract(int a, int b) {
    29.     return a - b;
    30. }
    32. int multiply(int a, int b) {
    33.     return a * b;
    34. }
    36. int divide(int a, int b) {
    37.     assert(b);  // Check for divide by zero.
    38.     return a / b;
    39. }
    这样就构造了一个结构体数组，用来保存运算符号和运算方法的一个映射关系，后续只要在operator_function_map数组里面去根据符号找到执行方法就可以了。

    find_operator_function_by_string函数就是执行了上面说的这个功能，根据传入的操作符号找到对应的函数，并进行返回函数指针。

    perform_operation函数中对于传入的参数进行解析，先解析第一个放到临时变量value中，然后再循环体重进行解析操作符获取计算方法的函数指针，然后再获取另一个操作数，进行执行计算函数，然后返回值会转储到value中方便下次继续使用。肯定有一些错误告警日志信息以及错误判断。最终如果参数无误，将计算的结果进行返回。还有就是在这个函数中会分配一块内存用来存储每一次计算得到的中间值信息。

    最后的main函数就是调用测试的过程，后续应该把这个main.c该为example_main.c，否则会在calculator_test.c函数编译的过程中出错。

    关于不能执行乘法的解释：
        在以./a.out 2 * 3  这个命令行进行执行程序的时候，会将其中*号解析为一个通配符，即当前目录下的所有内容名字的集合。  如果想正常调用乘法的话，可以将 * 号用单引号进行包起来就可以正常的调用了。还有就是这个方法只会从左向右进行计算，不会进行优先级的区分（有兴趣可以进一步完善哟）。
    运行结果如下：

    calculator_test.c函数中对于calculator.c函数中的方法进行了单元测试，需要在calculator.c的最开始添加一行  #define UNIT_TESTING 1  这样使能单元测试功能。然后执行make：
    1. test : cmockery.c calculator.c calculator_test.c
    2. 	gcc cmockery.c calculator.c  calculator_test.c  -g -O0 -o test 
    3. clean:
    4. 	rm -f test

    calculator_test.c中的main函数如下：
    1. int main(int argc, char* argv[]) {
    2. 	UnitTest tests[] = {
    3. 		unit_test(test_add),
    4. 		unit_test(test_subtract),
    5. 		unit_test(test_multiply),
    6. 		unit_test(test_divide),
    7. 		unit_test(test_divide_by_zero),
    8. 		unit_test(test_find_operator_function_by_string_null_functions),
    9. 		unit_test(test_find_operator_function_by_string_null_string),
    10. 		unit_test(test_find_operator_function_by_string_valid_null_functions),
    11. 		unit_test(test_find_operator_function_by_string_not_found),
    12. 		unit_test(test_find_operator_function_by_string_found),
    13. 		unit_test(test_perform_operation_null_args),
    14. 		unit_test(test_perform_operation_null_operator_functions),
    15. 		unit_test(test_perform_operation_null_number_of_intermediate_values),
    16. 		unit_test(test_perform_operation_null_intermediate_values),
    17. 		unit_test(test_perform_operation_no_arguments),
    18. 		unit_test(test_perform_operation_first_arg_not_integer),
    19. 		unit_test(test_perform_operation_unknown_operator),
    20. 		unit_test(test_perform_operation_missing_argument),
    21. 		unit_test(test_perform_operation_no_integer_after_operator),
    22. 		unit_test(test_perform_operation),
    23. 		unit_test(test_example_main_no_args),
    24. 		unit_test(test_example_main),
    25. 	};
    26. 	return run_tests(tests);
    27. }
    其中的前四个单元测试就是简单的一个断言测试，取test_add为例，如下：
    1. // Ensure add() adds two integers correctly.
    2. void test_add(void **state) {
    3. 	assert_int_equal(add(3, 3), 6);
    4. 	assert_int_equal(add(3, -3), 0);
    5. }
    test_divide_by_zero，test_find_operator_function_by_string_null_functions，test_find_operator_function_by_string_null_string测试，使用expect_assert_failure，确认100/0是非法的。否则会无法通过测试。

    最核心的两个函数如下，重要的位置都加了注释。
    2. int _run_test(
    3.         const char * const function_name,  const UnitTestFunction Function,
    4.         void ** const state, const UnitTestFunctionType function_type,
    5.         const void* const heap_check_point) {
    6.     const ListNode * const check_point = heap_check_point ?
    7.         heap_check_point : check_point_allocated_blocks();
    8.     void *current_state = NULL;
    9.     int rc = 1;
    10.     int handle_exceptions = 1;
    11. #ifdef _WIN32
    12.     handle_exceptions = !IsDebuggerPresent();
    13. #endif // _WIN32
    14. #if UNIT_TESTING_DEBUG
    15.     handle_exceptions = 0;
    16. #endif // UNIT_TESTING_DEBUG
    18.     if (handle_exceptions) {
    19. #ifndef _WIN32
    20.         unsigned int i;
    21.         //注册新号处理函数，出现异常的时候，会跳到exception_handler这里去处理，
    22.         //然后再exception_handler调用longjmp跳回到setjmp位置继续下一次单元测试。
    23.         //会返回并保存默认的信号处理方发指针
    24.         for (i = 0; i < ARRAY_LENGTH(exception_signals); i++) {
    25.             default_signal_functions[i] = signal(
    26.                 exception_signals[i], exception_handler);
    27.         }
    28. #else // _WIN32
    29.         previous_exception_filter = SetUnhandledExceptionFilter(
    30.             exception_filter);
    31. #endif // !_WIN32
    32.     }
    34.     if (function_type == UNIT_TEST_FUNCTION_TYPE_TEST) {
    35.         print_message("%s: Starting test
", function_name);
    36.     }
    37.     initialize_testing(function_name);
    38.     global_running_test = 1;
    39.     //在这里进行的setjmp，后续如果出现新号或者错误处理，后会返回这里继续else部分的执行。
    40.     if (setjmp(global_run_test_env) == 0) {
    41.         Function(state ? state : &current_state);
    42.         fail_if_leftover_values(function_name);
    44.         /* If this is a setup function then ignore any allocated blocks
    45.          * only ensure they're deallocated on tear down. */
    46.         if (function_type != UNIT_TEST_FUNCTION_TYPE_SETUP) {
    47.             fail_if_blocks_allocated(check_point, function_name);
    48.         }
    50.         global_running_test = 0;
    52.         if (function_type == UNIT_TEST_FUNCTION_TYPE_TEST) {
    53.             print_message("%s: Test completed successfully.
", function_name);
    54.         }
    55.         rc = 0;
    56.     } else {
    57.         global_running_test = 0;
    58.         print_message("%s: Test failed.
", function_name);
    59.     }
    60.     teardown_testing(function_name);
    62.     if (handle_exceptions) {
    63. #ifndef _WIN32
    64.         unsigned int i;
    65.         //在这里回复默认的异常处理函数，每一个单元测试都要这么做一次。
    66.         for (i = 0; i < ARRAY_LENGTH(exception_signals); i++) {
    67.             signal(exception_signals[i], default_signal_functions[i]);
    68.         }
    69. #else // _WIN32
    70.         if (previous_exception_filter) {
    71.             SetUnhandledExceptionFilter(previous_exception_filter);
    72.             previous_exception_filter = NULL;
    73.         }
    74. #endif // !_WIN32
    75.     }
    77.     return rc;
    78. }
    81. int _run_tests(const UnitTest * const tests, const size_t number_of_tests) {
    82.     print_message("%d
",sizeof(int));
    83.     // 是否执行下一个测试.
    84.     int run_next_test = 1;
    85.     // 是否前一个测试执行失败了.
    86.     int previous_test_failed = 0;
    87.     //检查堆指针的状态
    88.     const ListNode * const check_point = check_point_allocated_blocks();
    89.     //当前的测试索引
    90.     size_t current_test = 0;
    91.     //已经执行过测试的个数
    92.     size_t tests_executed = 0;
    93.     //测试失败的数目
    94.     size_t total_failed = 0;
    95.     // setup 函数的个数
    96.     size_t setups = 0;//(setup主要实现测试前的初始化工作，teardown主要实现测试完成后的垃圾回收工作)
    97.     // teardown 函数的个数
    98.     size_t teardowns = 0;
    99.     /* 一个测试状态的栈.  一个状态是当测试的setup发生时入栈
    100.      * 另个是当测试的teardown发生时出栈 */
    101.     TestState* test_states = malloc(number_of_tests * sizeof(*test_states));
    102.     size_t number_of_test_states = 0;
    103.     //失败测试的名字指针数组，最多为所有的都失败
    104.     const char** failed_names = malloc(number_of_tests *
    105.                                        sizeof(*failed_names));
    106.     void **current_state = NULL;
    107.     //确保最大的整数类型要不小于一个指针类型
    108.     assert_true(sizeof(LargestIntegralType) >= sizeof(void*));
    109.     
    110.     while (current_test < number_of_tests) 
    111.     {
    112.         const ListNode *test_check_point = NULL;
    113.         TestState *current_TestState;
    114.         const UnitTest * const test = &tests[current_test++];
    115.         if (!test->function) 
    116.         {//如果结构体中的函数指针为空，那么就continue
    117.             continue;
    118.         }
    119.         //以run_next_test控制是否为test，区分setup必须首先被执行。
    120.         switch (test->function_type) 
    121.         {
    122. 	        case UNIT_TEST_FUNCTION_TYPE_TEST:
    123. 	            run_next_test = 1;
    124. 	            break;
    125. 	        case UNIT_TEST_FUNCTION_TYPE_SETUP: 
    126. 	        {
    127. 	            // Checkpoint the heap before the setup.
    128. 	            current_TestState = &test_states[number_of_test_states++];
    129. 	            current_TestState->check_point = check_point_allocated_blocks();
    130. 	            test_check_point = current_TestState->check_point;
    131. 	            current_state = &current_TestState->state;
    132. 	            *current_state = NULL;
    133. 	            run_next_test = 1;
    134. 	            setups ++;
    135. 	            break;
    136.        		 }
    137.         case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
    138.             // Check the heap based on the last setup checkpoint.
    139.             assert_true(number_of_test_states);
    140.             current_TestState = &test_states[--number_of_test_states];
    141.             test_check_point = current_TestState->check_point;
    142.             current_state = &current_TestState->state;
    143.             teardowns ++;
    144.             break;
    145.         default:
    146.             print_error("Invalid unit test function type %d
",
    147.                         test->function_type);
    148.             exit_test(1);
    149.             break;
    150.         }
    152.         if (run_next_test)
    153.         {//进入测试单元进行运行函数
    154.             int failed = _run_test(test->name, test->function, current_state,
    155.                                    test->function_type, test_check_point);
    156.             if (failed)
    157.             {//记录错误函数的名字，后续会用来记录输出
    158.                 failed_names[total_failed] = test->name;
    159.             }
    161.             switch (test->function_type)
    162.             {//统计信息
    163. 	            case UNIT_TEST_FUNCTION_TYPE_TEST:
    164. 	                previous_test_failed = failed;
    165. 	                total_failed += failed;
    166. 	                tests_executed ++;
    167. 	                break;
    169. 	            case UNIT_TEST_FUNCTION_TYPE_SETUP:
    170. 	                if (failed) 
    171. 	                {
    172. 	                    total_failed ++;
    173. 	                    tests_executed ++;
    174. 	                    // Skip forward until the next test or setup function.
    175. 	                    run_next_test = 0;
    176. 	                }
    177. 	                previous_test_failed = 0;
    178. 	                break;
    180. 	            case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
    181. 	                // If this test failed.
    182. 	                if (failed && !previous_test_failed) 
    183. 	                {
    184. 	                    total_failed ++;
    185. 	                }
    186. 	                break;
    187. 	            default:
    188. 	                assert_false("BUG: shouldn't be here!");
    189. 	                break;
    190.             }
    191.         }
    192.     }
    193.     //输出打印信息，并且释放申请的资源
    194.     if (total_failed)
    195.     {
    196.         size_t i;
    197.         print_error("%d out of %d tests failed!
", total_failed,
    198.                     tests_executed);
    199.         for (i = 0; i < total_failed; i++) 
    200.         {
    201.             print_error("    %s
", failed_names[i]);
    202.         }
    203.     } 
    204.     else 
    205.     {
    206.         print_message("All %d tests passed
", tests_executed);
    207.     }
    209.     if (number_of_test_states) 
    210.     {
    211.         print_error("Mismatched number of setup %d and teardown %d "
    212.                     "functions
", setups, teardowns);
    213.         total_failed = -1;
    214.     }
    216.     free(test_states);
    217.     free((void*)failed_names);
    218.     //如果在这里还没有回复堆区域，那么就说明内存存在泄漏
    219.     fail_if_blocks_allocated(check_point, "run_tests");
    220.     return (int)total_failed;
    221. }
    后续这个测试框架可以以静态库的方式存在于项目中，单独的简历一个测试文件夹，专门用于各个模块的单元测试代码。或者就编译成动态库安装到系统里，都是可以的。
  • 相关阅读:
    MySQL 简单查询（实验回顾）
    PicGo + Gitee 创建图床，Typora竟还有这种功能
    SQL 条件判断
    django ORM中的复选MultiSelectField的使用
    with的用法
    django update-or-create的用法
    获取异常文件
    支付宝支付
    单例模式创建
    数据类模型
  • 原文地址：https://www.cnblogs.com/cfzhang/p/a1d8bd91d72fbe49bd015471b049f2bb.html
Copyright © 2011-2022 走看看