（八）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是非法的。否則會無法通過測試。

最核心的兩個函數如下，重要的位置都加了注釋。