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

所分析的calculator.c和calculator_test.c文件位于工程中的 cmockery/src/example/ 目录下，是一个相对而言比较全面的样例程序，用到了cmockery项目中的大多数单元测试方法。基本上涵盖了之前所有的样例程序中的用法，还有两组测试是database操作的样例程序没有做分析也不准备去做了。在结束了这一个样例程序的分析之后，大概就可以将整个cmockery程序过了百分之70的样子，接下来就可以将整个项目代码过一遍了。

calculator.c

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <assert.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define UNIT_TESTING 1
// If this is being built for a unit test.
#if UNIT_TESTING
/* Redirect printf to a function in the test application so it's possible to
* test the standard output. */
#ifdef printf
#undef printf
#endif // printf
#define printf example_test_printf
extern void print_message(const char *format, ...);
extern int example_test_printf(const char *format, ...);
/* Redirect fprintf to a function in the test application so it's possible to
* test error messages. */
#ifdef fprintf
#undef fprintf
#endif // fprintf
#define fprintf example_test_fprintf
extern int example_test_fprintf(FILE * const file, const char *format, ...);
// Redirect assert to mock_assert() so assertions can be caught by cmockery.
#ifdef assert
#undef assert
#endif // assert
#define assert(expression) \
mock_assert((int)(expression), #expression, __FILE__, __LINE__)
void mock_assert(const int result, const char* expression, const char *file,
const int line);
/* Redirect calloc and free to test_calloc() and test_free() so cmockery can
* check for memory leaks. */
#ifdef calloc
#undef calloc
#endif // calloc
#define calloc(num, size) _test_calloc(num, size, __FILE__, __LINE__)
#ifdef free
#undef free
#endif // free
#define free(ptr) _test_free(ptr, __FILE__, __LINE__)
void* _test_calloc(const size_t number_of_elements, const size_t size,
const char* file, const int line);
void _test_free(void* const ptr, const char* file, const int line);
/* main is defined in the unit test so redefine name of the the main function
* here. */
#define main example_main
/* All functions in this object need to be exposed to the test application,
* so redefine static to nothing. */
#define static
#endif // UNIT_TESTING
// A binary arithmetic integer operation (add, subtract etc.)
typedef int (*BinaryOperator)(int a, int b);
// Structure which maps operator strings to functions.
typedef struct OperatorFunction {
const char* operator;
BinaryOperator function;
} OperatorFunction;
int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
int divide(int a, int b);
// Associate operator strings to functions.
static OperatorFunction operator_function_map[] = {
{"+", add},
{"-", subtract},
{"*", multiply},
{"/", divide},
};
int add(int a, int b) {
return a + b;
}
int subtract(int a, int b) {
return a - b;
}
int multiply(int a, int b) {
return a * b;
}
int divide(int a, int b) {
assert(b); // Check for divide by zero.
return a / b;
}
/* Searches the specified array of operator_functions for the function
* associated with the specified operator_string. This function returns the
* function associated with operator_string if successful, NULL otherwise.
*/
BinaryOperator find_operator_function_by_string(
const size_t number_of_operator_functions,
const OperatorFunction * const operator_functions,
const char* const operator_string) {
size_t i;
assert(!number_of_operator_functions || operator_functions);
assert(operator_string);
for (i = 0; i < number_of_operator_functions; i++) {
const OperatorFunction *const operator_function =
&operator_functions[i];
if (strcmp(operator_function->operator, operator_string) == 0) {
return operator_function->function;
}
}
return NULL;
}
/* Perform a series of binary arithmetic integer operations with no operator
* precedence.
*
* The input expression is specified by arguments which is an array of
* containing number_of_arguments strings. Operators invoked by the expression
* are specified by the array operator_functions containing
* number_of_operator_functions, OperatorFunction structures. The value of
* each binary operation is stored in a pointer returned to intermediate_values
* which is allocated by malloc().
*
* If successful, this function returns the integer result of the operations.
* If an error occurs while performing the operation error_occurred is set to
* 1, the operation is aborted and 0 is returned.
*/
int perform_operation(
int number_of_arguments, char *arguments[],
const size_t number_of_operator_functions,
const OperatorFunction * const operator_functions,
int * const number_of_intermediate_values,
int ** const intermediate_values, int * const error_occurred) {
char *end_of_integer;
int value;
unsigned int i;
assert(!number_of_arguments || arguments);
assert(!number_of_operator_functions || operator_functions);
assert(error_occurred);
assert(number_of_intermediate_values);
assert(intermediate_values);
*error_occurred = 0;
*number_of_intermediate_values = 0;
*intermediate_values = NULL;
if (!number_of_arguments)
return 0;
// Parse the first value.
value = (int)strtol(arguments[0], &end_of_integer, 10);
if (end_of_integer == arguments[0]) {
// If an error occurred while parsing the integer.
fprintf(stderr, "Unable to parse integer from argument %s\n",
arguments[0]);
*error_occurred = 1;
return 0;
}
// Allocate an array for the output values.
*intermediate_values = calloc(((number_of_arguments - 1) / 2),
sizeof(**intermediate_values));
i = 1;
while (i < number_of_arguments) {
int other_value;
const char* const operator_string = arguments[i];
const BinaryOperator function = find_operator_function_by_string(
number_of_operator_functions, operator_functions, operator_string);
int * const intermediate_value =
&((*intermediate_values)[*number_of_intermediate_values]);
(*number_of_intermediate_values) ++;
if (!function) {
fprintf(stderr, "Unknown operator %s, argument %d\n",
operator_string, i);
*error_occurred = 1;
break;
}
i ++;
if (i == number_of_arguments) {
fprintf(stderr, "Binary operator %s missing argument\n",
operator_string);
*error_occurred = 1;
break;
}
other_value = (int)strtol(arguments[i], &end_of_integer, 10);
if (end_of_integer == arguments[i]) {
// If an error occurred while parsing the integer.
fprintf(stderr, "Unable to parse integer %s of argument %d\n",
arguments[i], i);
*error_occurred = 1;
break;
}
i ++;
// Perform the operation and store the intermediate value.
*intermediate_value = function(value, other_value);
value = *intermediate_value;
}
if (*error_occurred) {
free(*intermediate_values);
*intermediate_values = NULL;
*number_of_intermediate_values = 0;
return 0;
}
return value;
}
int main(int argc, char *argv[]) {
int return_value;
int number_of_intermediate_values;
int *intermediate_values;
// Peform the operation.
const int result = perform_operation(
argc - 1, &argv[1],
sizeof(operator_function_map) / sizeof(operator_function_map[0]),
operator_function_map, &number_of_intermediate_values,
&intermediate_values, &return_value);
// If no errors occurred display the result.
if (!return_value && argc > 1) {
unsigned int i;
unsigned int intermediate_value_index = 0;
printf("%s\n", argv[1]);
for (i = 2; i < argc; i += 2) {
assert(intermediate_value_index < number_of_intermediate_values);
printf(" %s %s = %d\n", argv[i], argv[i + 1],
intermediate_values[intermediate_value_index++]);
}
printf("= %d\n", result);
}
if (intermediate_values) {
free(intermediate_values);
}
return return_value;
}

这个是calculator.c的源码，里面自带了一个main.c程序。这个文件可以直接编译：gcc calculator.c 然后生成 a.out之后运行就是： ./a.out 1 + 2 - 3 + 4。我在做测试的时候发现不能很好的支持*号。

// A binary arithmetic integer operation (add, subtract etc.)
typedef int (*BinaryOperator)(int a, int b);
// Structure which maps operator strings to functions.
typedef struct OperatorFunction {
const char* operator;
BinaryOperator function;
} OperatorFunction;
int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
int divide(int a, int b);
// Associate operator strings to functions.
static OperatorFunction operator_function_map[] = {
{"+", add},
{"-", subtract},
{"*", multiply},
{"/", divide},
};
int add(int a, int b) {
return a + b;
}
int subtract(int a, int b) {
return a - b;
}
int multiply(int a, int b) {
return a * b;
}
int divide(int a, int b) {
assert(b); // Check for divide by zero.
return a / b;
}

这样就构造了一个结构体数组，用来保存运算符号和运算方法的一个映射关系，后续只要在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：

test : cmockery.c calculator.c calculator_test.c
gcc cmockery.c calculator.c calculator_test.c -g -O0 -o test
clean:
rm -f test

calculator_test.c中的main函数如下：

int main(int argc, char* argv[]) {
UnitTest tests[] = {
unit_test(test_add),
unit_test(test_subtract),
unit_test(test_multiply),
unit_test(test_divide),
unit_test(test_divide_by_zero),
unit_test(test_find_operator_function_by_string_null_functions),
unit_test(test_find_operator_function_by_string_null_string),
unit_test(test_find_operator_function_by_string_valid_null_functions),
unit_test(test_find_operator_function_by_string_not_found),
unit_test(test_find_operator_function_by_string_found),
unit_test(test_perform_operation_null_args),
unit_test(test_perform_operation_null_operator_functions),
unit_test(test_perform_operation_null_number_of_intermediate_values),
unit_test(test_perform_operation_null_intermediate_values),
unit_test(test_perform_operation_no_arguments),
unit_test(test_perform_operation_first_arg_not_integer),
unit_test(test_perform_operation_unknown_operator),
unit_test(test_perform_operation_missing_argument),
unit_test(test_perform_operation_no_integer_after_operator),
unit_test(test_perform_operation),
unit_test(test_example_main_no_args),
unit_test(test_example_main),
};
return run_tests(tests);
}

其中的前四个单元测试就是简单的一个断言测试，取test_add为例，如下：

// Ensure add() adds two integers correctly.
void test_add(void **state) {
assert_int_equal(add(3, 3), 6);
assert_int_equal(add(3, -3), 0);
}

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是非法的。否则会无法通过测试。

最核心的两个函数如下，重要的位置都加了注释。