闪灵屋

/* test.c */
int maxi(int i, int j)
{
    return i > j ? i : j;
}

/* testcase.c */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <CUnit/CUnit.h>
 
/**
 * 待测试的函数
 */
extern int maxi(int i, int j);
 
/**
 * 测试函数
 * 必须满足签名式 void func(void)
*/
void testIQJ(void)
{
    CU_ASSERT_EQUAL(maxi(1,1),1);
    CU_ASSERT_EQUAL(maxi(0,-0),0);
}
void testIGJ(void)
{
    CU_ASSERT_EQUAL(maxi(2,1),2);
    CU_ASSERT_EQUAL(maxi(0,-1),0);
    CU_ASSERT_EQUAL(maxi(-1,-2),-1);
}
void testILJ(void)
{
    CU_ASSERT_EQUAL(maxi(1,2),2);
    CU_ASSERT_EQUAL(maxi(-1,0),0);
    CU_ASSERT_EQUAL(maxi(-2,-1),-1);
}
 
/**
 * 测试函数信息的结构体
 * 当然也可以使用 CU_add_test()
 * 注意必须以 CU_TEST_INFO_NULL 结尾
 */
CU_TestInfo testcases[] =
{
    {"Testing i equals j:", testIQJ},
    {"Testing i greater than j:", testIGJ},
    {"Testing i less than j:", testILJ},
    CU_TEST_INFO_NULL
};
 
/**
 * 测试套件初始化函数，对测试函数中的资源进行初始化
 * 返回0为成功，如果返回失败则此套件下的测试均不运行
 */
int suite_init(void)
{
    return 0;
}
 
/**
 * 测试套件销毁函数，对测试函数中的资源进行销毁
 * 返回0为成功，如果返回失败不影响测试，只会报测试套件运行错误
 */
int suite_clean(void)
{
    return 0;
}
 
/**
* 测试套件信息的结构体
* 当然也可以使用 CU_add_suite()
* 注意必须以 CU_SUITE_INFO_NULL 结尾
* 如不需要初始化或者最终化函数则可以传NULL
*/
CU_SuiteInfo suites[] =
{
    {"Testing the function maxi:", suite_init, suite_clean, testcases},
    CU_SUITE_INFO_NULL
};
 
/**
 * 增加到Registry中
 */
void AddTests(void)
{
    assert(NULL != CU_get_registry());
    assert(!CU_is_test_running());
 
    if(CUE_SUCCESS != CU_register_suites(suites)){
        fprintf(stderr, "Register suites failed - %s ", CU_get_error_msg());
        exit(EXIT_FAILURE);
    }
}

/* main.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <CUnit/Basic.h>
#include <CUnit/Automated.h>
#include <CUnit/Console.h>
 
extern void AddTests(void);
 
int main(int argc, char* argv[])
{
    /* 为Basic模式使用 */
    CU_BasicRunMode mode = CU_BRM_VERBOSE;
    CU_ErrorAction error_action = CUEA_IGNORE;
    int i;
 
    setvbuf(stdout, NULL, _IONBF, 0);
 
    for (i=1 ; i<argc ; i++) {
        if (!strcmp("-i", argv[i])) {
            error_action = CUEA_IGNORE;
        }
        else if (!strcmp("-f", argv[i])) {
            error_action = CUEA_FAIL;
        }
        else if (!strcmp("-A", argv[i])) {
            error_action = CUEA_ABORT;
        }
        else if (!strcmp("-s", argv[i])) {
            mode = CU_BRM_SILENT;
        }
        else if (!strcmp("-n", argv[i])) {
            mode = CU_BRM_NORMAL;
        }
        else if (!strcmp("-v", argv[i])) {
            mode = CU_BRM_VERBOSE;
        }
        else if (!strcmp("-e", argv[i])) {
            return 0;
        }
        else {
            printf("\nUsage: BasicTest [options]\n\n"
                "Options: -i ignore framework errors [default].\n"
                " -f fail on framework error.\n"
                " -A abort on framework error.\n\n"
                " -s silent mode - no output to screen.\n"
                " -n normal mode - standard output to screen.\n"
                " -v verbose mode - max output to screen [default].\n\n"
                " -e print expected test results and exit.\n"
                " -h print this message and exit.\n\n");
            return 0;
        }
    }
 
    /* 初始化registry */
    if( CUE_SUCCESS != CU_initialize_registry())
    {
        return CU_get_error();
    }
    else
    {
        /* 增加测试套件suite */
        AddTests();
 
        /* 用不同模式运行 */
        /*CU_basic_set_mode(mode);
        CU_basic_run_tests();*/
 
        CU_automated_run_tests();
 
        /*CU_console_run_tests();*/
 
        /* 清除registry */
        CU_cleanup_registry();
    }
 
    return 0;
}