c语言实现一个单元测试框架(Unit Test Framework)代码

最新推荐文章于 2022-09-02 13:52:21 发布
最新推荐文章于 2022-09-02 13:52:21 发布
阅读量273 收藏 2
点赞数
文章标签： c/c++ 测试 操作系统


csdn lidp 转载注明出处

此单元测试框架为我在google code上的开源项目spider-tool的一部分，

关于spider-tool，欢迎访问google code.

https://spider-tool.googlecode.com


test_engine.h

/*
 * Spider -- An open source C language toolkit.
 *
 * Copyright (C) 2011 , Inc.
 *
 * lidp <openser@yeah.net>
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! 
  * \brief  Unit Test Framework
  *
  */

#ifndef _TEST_ENGINE_H
#define _TEST_ENGINE_H

#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif

#define SPD_TEST_FRAMEWORK

#ifdef SPD_TEST_FRAMEWORK
#define SPD_TEST_INIT(name) static enum spd_test_result name(struct spd_test_record *record, enum spd_test_cmd type, struct spd_test *test)
#define SPD_TEST_REGISTER(name) spd_test_register(name)
#define SPD_TEST_UNREGISTER(name) spd_test_unregister(name)
#define SPD_TEST_REPORT(name, category,file) spd_test_report(name, category,file)
#define SPD_TEST_RUN(name, category) spd_test_run(name, category)
#else 
#define SPD_TEST_INIT(name)
#define SPD_TEST_REGISTER(name)
#define SPD_TEST_UNREGISTER(name)
#define SPD_TEST_REPORT(name, category,file)
#define SPD_TEST_RUN(name, category)
#endif

enum spd_test_result {
	TEST_RESULT_NOT_RUN,
	TEST_RESULT_PASS,
	TEST_RESULT_FAILED,
};

enum spd_test_cmd {
	SPD_TEST_CMD_INIT,
	SPD_TEST_CMD_RUN,
};

struct spd_test_record {
	const char *name; /* unique name of this  test */
	const char *category; /*  test in this category can be run */
	const char *description; /*  a description of test  */
};

struct spd_test;

typedef enum spd_test_result (spd_test_cb_t)(struct spd_test_record *record, enum spd_test_cmd type, struct spd_test* test);

/* register a test record */
int spd_test_register(spd_test_cb_t *cb);

/* unresigster a test record  */
int spd_test_unregister(spd_test_cb_t *cb);


/* 
  * run test framework  in three mode :
  * name : run given name test case, may be NULL 
  * category : run a class of test of given category , may be NULL
  * if both name and category is NULL , will run all test case.
  *
  */
int spd_test_run(const char *name, const char *category);

/*!
  *\brief report test result in three mode ,by name, by category or all. may write result to textfile.
  */
int spd_test_report(const char *name, const char *category, const char *textfile);



int __spd_test_update_state(const char *file, const char *func, int line , struct spd_test *test, 
		const char *fmt, ...);

#define spd_test_update_state(test, fmt,...)  __spd_test_update_state(__FILE__, __PRETTY_FUNCTION__, __LINE__, (test), (fmt), ## __VA_ARGS__)

#if defined(__cplusplus) || defined(c_plusplus)
}
#endif

#endif

test_engine.c


/*
 * Spider -- An open source C language toolkit.
 *
 * Copyright (C) 2011 , Inc.
 *
 * lidp <openser@yeah.net>
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

#include "test_engine.h"
#include "logger.h"
#include "str.h"
#include "linkedlist.h"
#include "times.h"


 
/* stand for a  single test record */
struct spd_test {
	struct spd_test_record info;   /* store test info */
	enum spd_test_result result;   /* test result */
	struct spd_str *status_str;    /* test status in string */
	unsigned int howlong;  		   /* time this test cost */
	spd_test_cb_t *callback;       /* real func perform test work */
	SPD_LIST_ENTRY(spd_test)  list;
};

struct test_resultstr{
	enum spd_test_result result;
	const char* state;
} ;

static const struct test_resultstr test_result2str [] = {
		{TEST_RESULT_NOT_RUN, "NOT RUN"},
		{TEST_RESULT_PASS, "PASS"},
		{TEST_RESULT_FAILED, 

"FAILED"},
};

/* time mode */
enum test_type {
	TEST_NAME = 0,
	TEST_CATEGORY,
	TEST_ALL,
};

/*! global structure containing both total and last test execution results */
static struct spd_test_execute_results {
	unsigned int total_tests;  /*!< total number of tests, regardless if they have been executed or not */
	unsigned int total_passed; /*!< total number of executed tests passed */
	unsigned int total_failed; /*!< total number of executed tests failed */
	unsigned int total_time;   /*!< total time of all executed tests */
	unsigned int last_passed;  /*!< number of passed tests during last execution */
	unsigned int last_failed;  /*!< number of failed tests during last execution */
	unsigned int last_time;    /*!< total time of the last test execution */
} last_results;

static SPD_LIST_HEAD_STATIC(spd_test_list, spd_test);
static struct spd_test* spd_test_create(spd_test_cb_t*callback);
static struct spd_test* spd_test_free(struct spd_test *test);
static int spd_test_insert(struct spd_test *test);
static struct spd_test* spd_test_remove(spd_test_cb_t* cb);
static int spd_test_category_cmp(const char *cat1, const char *cat2);

int __spd_test_update_state(const char * file, const char * func, int line, struct spd_test * test, const char * fmt,...)
{
	struct spd_str *buf = NULL;
	va_list ap;

	if(!(buf = spd_str_create(128))) {
		return -1;
	}

	va_start(ap, fmt);
	spd_str_set_va(&buf, 0, fmt, ap);
	va_end(ap);

	spd_str_append(&test->status_str,0, "[%s:%s:%d]: %s",
			file, func, line,spd_str_buffer(buf));

	spd_safe_free(buf);

	return 0;
}

int spd_test_register(spd_test_cb_t *cb)
{
	struct spd_test *test;

	if(!cb) {
		spd_log(LOG_WARNING, "No callback be specified\n");
		return -1;
	}

	if(!(test = spd_test_create(cb))) {
		spd_log(LOG_WARNING, "failed to create test case\n");
		return -1;
	}

	if(spd_test_insert(test)) {
		spd_log(LOG_WARNING, "failed to insert test \n");
		spd_test_free(test);
		return -1;
	}

	return -1;
}

int spd_test_unregister(spd_test_cb_t *cb)
{
	struct spd_test *test;
	
	if(!cb)  {
		spd_log(LOG_WARNING, "No callback be specified\n");
		return -1;
	}

	if(!(test = spd_test_remove(cb))) {
		return -1;
	}

	spd_test_free(test);

	return 0;
}

static struct spd_test *spd_test_free(struct spd_test* test)
{
	if(!test) {
		return NULL;
	}

	spd_safe_free(test->status_str);
	spd_safe_free(test);

	return NULL;
}

static struct spd_test *spd_test_create(spd_test_cb_t * callback)
{
	struct spd_test *test = NULL;

	if(!callback || !(test = spd_calloc(1, sizeof(struct spd_test)))) {
		return NULL;
	}

	test->callback = callback;
	test->callback(&test->info, SPD_TEST_CMD_INIT, test);
	
	if(spd_strlen_zero(test->info.category)) {
		spd_log(LOG_WARNING, "No category set, cannot register. \n");
		return spd_test_free(test);
	}

	if(spd_strlen_zero(test->info.name)) {
		spd_log(LOG_WARNING, "No name set , cannot register. \n");
		return spd_test_free(test);
	}

	if(test->info.category[0] != '/' || test->info.category[strlen(test->info.category) - 1] != '/') {
		spd_log(LOG_WARNING, "category %s must start with / and end whith /.\n", test->info.category);
	}

	if(spd_strlen_zero(test->info.description)) {
		spd_log(LOG_WARNING, "NO desc set , cannot register.\n");
		return spd_test_free(test);
	}

	if(!(test->status_str = spd_str_create(128))) {
		return spd_test_free(test);
	}

	return test;
	
}

static int spd_test_insert(struct spd_test *test)
{	
	SPD_LIST_LOCK(&spd_test_list);
	SPD_LIST_INSERT_SORTALPHA(&spd_test_list, test,list,info.category);
	SPD_LIST_UNLOCK(&spd_test_list);

	return 0;
}

static struct spd_test* spd_test_remove(spd_test_cb_t *cb)
{
	struct spd_test *cur = NULL;

	SPD_LIST_LOCK(&spd_test_list);
	SPD_LIST_TRAVERSE_SAFE_BEGIN(&spd_test_list, cur, list) {
		if(cur->callback == cb) {
			SPD_LIST_REMOVE_CURRENT(&spd_test_list, list);
			break;
		}
	}
	SPD_LIST_TRAVERSE_SAFE_END;
	SPD_LIST_UNLOCK(&spd_test_list);

	return cur;
}

static int spd_test_category_cmp(const char *cat1, const char *cat2)
{
	int len1 = 0;
	int len2 = 0;

	if (!cat1 || !cat2) {
		return -1;
	}

	len1 = strlen(cat1);
	len2 = strlen(cat2);

	if (len2 > len1) {
		return -1;
	}

	return strncmp(cat1, cat2, len2) ? 1 : 0;
}

static int run_one(struct spd_test *test)
{
	
	struct timeval start =  spd_tvnow();
	
	spd_str_reset(test->status_str);
	
	test->result = test->callback(&test->info, SPD_TEST_CMD_RUN, test);
	
	test->howlong = spd_tvdiff_ms(spd_tvnow(), start);

	return 0;
}

int spd_test_run(const char * name, const char * category)
{
	enum test_type mode = TEST_ALL;
	struct spd_test *test = NULL;
	int ret = 0;
	int run = 0;
	
	if(!spd_strlen_zero(category)) {
		if(spd_strlen_zero(name)) {
			mode = TEST_NAME;
		} else {
			mode = TEST_CATEGORY;
		}
	}

	SPD_LIST_LOCK(&spd_test_list);

	memset(&last_results, 0, sizeof(last_results));
	SPD_LIST_TRAVERSE(&spd_test_list, test, list) {
		run = 0;
		switch(mode) {
		case TEST_CATEGORY:
			if(!spd_test_category_cmp(test->info.category, category)) {
				run = 1;
			}
			break;
		case TEST_NAME:
			if(!spd_test_category_cmp(test->info.category, category) && !strcmp(test->info.name, name)) {
				run = 1;
			}
			break;
		case TEST_ALL:
			run = 1;
			break;
		}

		if(run) {
			spd_log(LOG_DEBUG, "START Unite Test  %s - %s \n",test->info.category, test->info.name);

			run_one(test);

			last_results.last_time += test->howlong;
			if(test->result == TEST_RESULT_PASS) {
				last_results.last_passed++;
			} else if(test->result = TEST_RESULT_FAILED) {
				last_results.last_failed++;
			}
		}

		last_results.total_time += test->howlong;
		last_results.total_tests++;
		if(test->result != TEST_RESULT_NOT_RUN) {
			if(test->result == TEST_RESULT_PASS) {
				last_results.total_passed++;
			} else {
				last_results.total_failed++;
			}
		}
	}
	
	ret = last_results.total_passed + last_results.total_failed;

	if(!(last_results.last_passed + last_results.last_failed)) {
		spd_log(LOG_WARNING, "No Test Found.\n ");
		return ret;
	} else {
	
		spd_log(LOG_NOTICE, "Number of Tests:            %d\n", (last_results.last_passed + last_results.last_failed));
		spd_log(LOG_NOTICE, "Number of Tests Executed:   %d\n",last_results.total_tests);
		spd_log(LOG_NOTICE, "Passed Tests:               %d\n", last_results.last_passed);
		spd_log(LOG_NOTICE, "Failed Tests:               %d\n",last_results.last_failed);
		spd_log(LOG_NOTICE, "Total Execution Time:       %d\n", last_results.total_time);
	}
	
	SPD_LIST_UNLOCK(&spd_test_list);
	
	return ret;
}

static void test_report_one(FILE *txtfile, const struct spd_test *test)
{
	if(!txtfile || !test) {
		return;
	}

	fprintf(txtfile, "\nName:           %s\n", test->info.name);
	fprintf(txtfile, "Category:         %s\n", test->info.category);
	fprintf(txtfile, "Description:      %s\n", test->info.description);
	fprintf(txtfile, "Result:           %s\n", test_result2str[test->result].state);

	if(test->result != TEST_RESULT_NOT_RUN) {
		fprintf(txtfile, "Time:          %d\n",test->howlong);
	}

	if(test->result == TEST_RESULT_FAILED) {
		fprintf(txtfile, "Error Description:  %s\n", spd_str_buffer(test->status_str));
	}
}

int spd_test_report(const char * name, const char * category, const char * textfile)
{
	enum test_type mode = TEST_ALL;
	FILE *ftext;
	struct spd_test *test = NULL;

	if(!spd_strlen_zero(category)) {
		if(spd_strlen_zero(name)) {
			mode = TEST_NAME;
		} else {
			mode = TEST_CATEGORY;
		}
	}

	if(!spd_strlen_zero(textfile)) {
		if(!(ftext = fopen(textfile, "w"))) {
			spd_log(LOG_ERROR, "cannot open textfile : %s\n", textfile);
			return -1;
		}
	}

	SPD_LIST_LOCK(&spd_test_list);

	if(ftext) {
		fprintf(ftext,"Number of Tests:            %d\n", last_results.total_tests);
		fprintf(ftext,"Number of Tests Executed:   %d\n",(last_results.total_passed + last_results.total_failed));
		fprintf(ftext,"Passed Tests:               %d\n", last_results.total_passed);
		fprintf(ftext,"Failed Tests:               %d\n", last_results.total_failed);
		fprintf(ftext,"Total Execution Time:       %d\n", last_results.total_time);
	}

	SPD_LIST_TRAVERSE(&spd_test_list, test, list) {
		
		switch(mode) {
		case TEST_CATEGORY:
			if(!spd_test_category_cmp(test->info.category, category)) {
				test_report_one(ftext, test);
			}
			break;
		case TEST_NAME:
			if(!spd_test_category_cmp(test->info.category, category) && !strcmp(test->info.name, name)) {
				test_report_one(ftext, test);
			}
			break;
		case TEST_ALL:
			test_report_one(ftext, test);
			break;
		}
	}
	
	SPD_LIST_UNLOCK(&spd_test_list);

	if(ftext)
		fclose(ftext);

	return 0;
}

测试 代码： 


enum {
	FAMILY = 0,
	KEY = 1,
	VALUE = 2,
};

SPD_TEST_INIT(test_db)
{
	int res = TEST_RESULT_PASS;
	int i;
	char buf[sizeof(large_name)] = {0,};
	const char *inputs[][3] = {
		{"family", "key", "value"},
		{"dbtest", "a", "b"},
		{"dbtest", "a", "a"},
		{"dbtest", "b", "a"},
		{"dbtest", "b", "b"},
	};

 	switch(type) {
		case SPD_TEST_CMD_INIT:
			record->name = "test_db";
			record->category = "/spider/db/";
			record->description = "spd db get|put|del unit test";
			
			return TEST_RESULT_NOT_RUN;
			
		case SPD_TEST_CMD_RUN:
			break;
	}
	
	for(i = 0; i < ARRAY_LEN(inputs); i++) {

		if(spd_db_put(inputs[i][FAMILY], inputs[i][KEY], inputs[i][VALUE])) {
			spd_log(LOG_ERROR, "test failed in db put %s : %s : %s : \n", inputs[i][FAMILY], inputs[i][KEY], inputs[i][VALUE]);
			spd_test_update_state(test, "test failed in db put %s : %s : %s : \n", inputs[i][FAMILY], inputs[i][KEY], inputs[i][VALUE]);
			res = TEST_RESULT_FAILED;
		} 

		if(spd_db_get(inputs[i][FAMILY], inputs[i][KEY], buf, sizeof(buf))) {
			spd_log(LOG_ERROR, "test failed in db put %s : %s : %s : \n", inputs[i][FAMILY], inputs[i][KEY], inputs[i][VALUE]);
			spd_test_update_state(test, "test failed in db put %s : %s : %s : \n", inputs[i][FAMILY], inputs[i][KEY], inputs[i][VALUE]);
			res = TEST_RESULT_FAILED;
		} else if (strcasecmp(inputs[i][VALUE], buf)) {
			spd_log(LOG_ERROR, "test failed in db get , this is not match value,expect %s but %s \n", buf,inputs[i][VALUE]);
			spd_test_update_state(test, "test failed in db get , this is not match value,expect %s but %s \n", buf,inputs[i][VALUE]);
			res = TEST_RESULT_FAILED;
		} else {
			//spd_log(LOG_NOTICE, "get success %s %s %s \n", inputs[i][FAMILY], inputs[i][KEY], buf);
		}
		
		if(spd_db_del(inputs[i][FAMILY], inputs[i][KEY])) {
			spd_log(LOG_ERROR, "test failed in db del %s : %s : \n", inputs[i][FAMILY], inputs[i][KEY]);
			spd_test_update_state(test, "test failed in db get , this is not match value,expect %s but %s \n", buf,inputs[i][VALUE]);
			res = TEST_RESULT_FAILED;
		}
		
	}

	return res;
}

int test_spddb()
{

	SPD_TEST_REGISTER(test_db);	
	SPD_TEST_RUN("test_db",NULL);
	SPD_TEST_REPORT("test_db", NULL, "/tmp/spddb_test");
	SPD_TEST_UNREGISTER(test_db);

	return 0;
}
piperzero
关注
C语言unit test单元测试类的实现(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-29 1490
C语言unit test单元测试类的实现unit test单元测试类的定义pUnitTest.h(完整源码)unit test单元测试类的定义pUnitTest.cpp(完整源码) unit test单元测试类的定义pUnitTest.h(完整源码) #ifndef __PSTRING_UTEST__ #define __PSTRING_UTEST__ #include <cstdio> #define _UTest_VERSION "1.0.0" const static char *
【时时三省】unity test 测试框架 下载（适用于c语言测试的测试框架）
最新发布
时时三省的博客
07-24 486
介绍 unity test 测试框架的下载
C语言-单元测试(自研)
weixin_45203607的博客
09-02 1366
在网上找了找C语言都没有类似java 的junit单元测试 ,反复测试自己写的模块非常费劲,特别是交叉模块测试的时候根本就无法弄
c语言实现一个单元测试框架(Unit Test Framework)
管子（zero）的杂乱空间
03-22 322
csdn lidp 转载注明出处 此单元测试框架为我在google code上的开源项目spider-tool的一部分， 关于spider-tool，欢迎访问google code. https://spider-tool.googlecode.com 单元测试框架接口应尽量简单并提供必要的功能，使用步骤： 1. 注册单元测试函数到测试框架 2. 运行测试框架 3.生成单元测试统...
C uint Test
09-20 942
API Sanity AutoTest Description: An automatic generator of basic unit tests for a shared C/C++ library. It helps to quickly generate simpl
unittest 单元测试
c_ios的博客
06-27 407
分为表达用例，收集用例，执行用例，生成报告四部分 1.表达用例 负责实现功能的函数，一般放在一个单独的py文件中 2.收集用例（一个测试类） （1）定义一个测试类，继承unittest.TestCase （2）以test_开头，定义测试函数 （3）每一个test_函数就是一个测试用例 （4）内部用assertxxx进行断言 例如：assertEqual（a，b），assertIn（a,b）, assertTrue(a) （5）需要导入unittest包 （6）setUp：类下面的每一个用例
C语言单元测试框架详解：第二篇
魏波
03-24 5049
目录 前言 Check框架 1、Check框架特点 2、Check框架使用 前言 常见C语言单元测试框架有： 1、Check 2、Gtest（Google Test） 3、CuTest 4、Cunit 5、CppUTest（Microsoft Cppunittest） 6、C++Test 7、Cmocka 8、Criterion Check框架 今天给大家介绍C语言单元测试框架：Check check官网：Check | Unit testing framework for C .
AUnit：受ArduinoUnit和Google Test启发的Arduino平台的单元测试框架。 与AUniter或EpoxyDuino一起使用以进行连续构建
02-01
AUnit是一个专为Arduino平台设计的单元测试框架，它的出现是为了填补Arduino开发中对系统级测试的空白。受到ArduinoUnit和Google Test的影响，AUnit旨在提供一个轻量级且易于使用的解决方案，帮助开发者确保他们的...
cxTest: an unit test framework for c-开源
04-25
总之，cxTest是一个为C语言开发者设计的轻量级、可移植的单元测试框架，它简化了C项目中的测试流程，增强了代码质量和可靠性。通过深入理解和使用cxTest，开发者可以更好地维护和优化他们的C语言项目。
一个简单的C语言测试框架
07-29
开始学习TDD，模仿了一下gtest和mockery，写一个简单的C语言测试框架，a Simple C Testing Framework (STest)。
一个小项目的cunit单元测试例子
08-13
包含了测试的完整框架，有测试文件，驱动文件，桩函数文件，Makefile，与测试源代码。对于初次接触单元测试的人来说可以说是一个简单易懂的学习例子。
Python：Unittest单元测试框架
热门推荐
不怕猫的耗子A
06-12 2万+
​单元测试 1、单元测试(unit testing)，是指对软件中的最小可测试代码单元进行检查和验证 ⑴是针对于代码的一种测试方法，测试的是代码 2、对于"代码单元"中单元的含义，一般来说，要根据实际情况去判定其具体含义： ⑴如C语言中单元指一个函数、Java里单元指一个类、图形化的软件中可以指一个窗口或一个菜单等 ⑵单元可以是一个函数、方法、类、功能模块或者子系统 ⑶总的来说，单元就是人为规定的最小的被测功能模块 3、单元测试针对的是每一个独立的代码单元，代码单元应不...
Unittest 源码分析系列----- （一）unittest运行原理
Lcicada_2021的博客
03-29 1313
占坑。。。。
【测试】Cunit单元测试
bandaoyu的note
04-09 924
《CUnit使用流程简介》 http://www.51testing.com/html/18/297918-867415.html 《CUnit使用教程》 http://blog.sina.com.cn/s/blog_77f51a340100qf6k.html 1.CUnit介绍： <wbr/>CUnit是完成测试的自动化工具，编写一定的代码就可以完成对工程的单元测试...
C语言单元测试框架——CUnit 安装(windows和Linux)及使用
qq_44610809的博客
01-07 7978
Cunit 安装以及使用
C语言单元测试框架 -CUnit
一叶竹
03-16 1879
使用CUnit对C代码进行单元测试,帮助更高效的编写代码 下载 https://sourceforge.net/projects/cunit/?source=typ_redirect 安装 sudo tar -jxzf CUnit-2.1-3.tar.bz2 sudo cd CUnit-2.1.3/ sudo ./bootstrap sudo ./
Check—强大的C语言单元测试框架
白杨的专栏
12-28 1万+
1. 前言在看基数树源码时，发现源码里面有个deps的依赖文件夹，deps里是一个叫Check的源码安装包，Google之后发现Check原来是C语言单元测试框架。关于单元测试，Wikipedia的介绍点这里。 Check 最主要的优点是对于每一个测试用例的运行都 fork 一个子进程，这么做的原因是因为 C 语言的独特性： (1) 其它语言如 Java，Python，Ruby等，单元测试
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值