# navo-tinytest

**Repository Path**: henryk/navo-tinytest

## Basic Information

- **Project Name**: navo-tinytest
- **Description**: TinyTest C/C++ 单元测试框架
C语言开发，GNUC、MSC均可编译
由于C++本身已经有诸如gtest、CppUnit等比较不错的单元测试工具
而C的单元测试比较少，平常有些测试对时间还需要精确到毫秒，精确到区分内核执行时间和用户执行时间，一般的C单元测试不支持这么变态的要求，所以就写了一个很简易的基于C的单元测试
暂不支持死亡测试和内存检测
- **Primary Language**: C
- **License**: LGPL-2.1
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 0
- **Created**: 2015-07-14
- **Last Updated**: 2022-01-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

TinyTest C/C++ 单元测试框架
C语言开发，GNUC、MSC均可编译
由于C++本身已经有诸如gtest、CppUnit等比较不错的单元测试工具
而C的单元测试比较少，平常有些测试对时间还需要精确到毫秒，精确到区分内核执行时间和用户执行时间，一般的C单元测试不支持这么变态的要求，所以就写了一个很简易的基于C的单元测试
暂不支持死亡测试和内存检测

 使用说明

一、主要测试功能

1) 加入tinytest.h和tinytest.c（C++工程中该名为tinytest.cpp）到工程，
   并在主函数文件包含tinytest.h头文件

#include "tinytest.h"


2) 在main函数写初始化和运行代码：

int main(int argc, char* argv[])
{
	TN_Init();

	return TN_Run();
}

3) 定义测试用例

TN_Test(HandleZeroInput)
{
	TN_TestBody()
	{
		// 加入测试代码
	}

	TN_Pass();
}

4) 注册测试

int main(int argc, char* argv[])
{
	TN_Init(argc, argv);

	// 注册单次测试，测试只会执行一次
	TN_Add_Single(HandleZeroInpu);

	// 注册多次测试，这个测试会执行10次，并且每次
	// 测试循环执行TestBody()中的测试代码100000遍
	TN_Add(ListPerform, 10, 100000);

	return TN_Run();
}

5) 期望与断言

int is_prime(int n);

TN_Test(HandleZeroInput)
{
	TN_TestBody()
	{
		char* str = "Hello";
		int ta = 1;
		double n = 5.0;
		int n = 25;

		TN_Expect(ta == 2);

		TN_Expect_StringEqual(str, "hello");

		TN_Assert_Near(n, 5.0, 0.2);

		TN_Assert_Pred1(is_prime, n);

		TN_Assert_Exception(*str = 'h');
	}

	TN_Pass();
}

以下为所有支持的期望与断言：

TN_Expect(exp)
TN_Expect_True(exp)
TN_Expect_False(exp)
TN_Expect_Equal(exp, val)
TN_Expect_NotEqual(exp, val)
TN_Expect_Ptr(exp, opr, val)
TN_Expect_Short(exp, opr, val)
TN_Expect_Int(exp, opr, val)
TN_Expect_Long(exp, opr, val)
TN_Expect_UShort(exp, opr, val)
TN_Expect_UInt(exp, opr, val)
TN_Expect_ULong(exp, opr, val)
TN_Expect_Single(exp, opr, val)
TN_Expect_Double(exp, opr, val)
TN_Expect_LongLong(exp, opr, val)
TN_Expect_ULongLong(exp, opr, val)
TN_Expect_LongLong(exp, opr, val)
TN_Expect_ULongLong(exp, opr, val)
TN_Expect_Near(exp, val, err)
TN_Expect_StringEqual(exp, val)
TN_Expect_StringNotEqual(exp, val)
TN_Expect_StringCaseEqual(exp, val)
TN_Expect_StringCaseNotEqual(exp, val)
TN_Expect_Pred1(pred, fmt1, pm1)
TN_Expect_Pred2(pred, fmt1, pm1, fmt2, pm2)
TN_Expect_Pred3(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3)
TN_Expect_Pred4(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3, fmt4, pm4)
TN_Expect_Pred5(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3, fmt4, pm4, fmt5, pm5)
TN_Expect_Pred6(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3, fmt4, pm4, fmt5, pm5, fmt6, pm6)

TN_Assert(exp)
TN_Assert_True(exp)
TN_Assert_False(exp)
TN_Assert_Equal(exp, val)
TN_Assert_NotEqual(exp, val)
TN_Assert_Ptr(exp, opr, val)
TN_Assert_Short(exp, opr, val)
TN_Assert_Int(exp, opr, val)
TN_Assert_Long(exp, opr, val)
TN_Assert_UShort(exp, opr, val)
TN_Assert_UInt(exp, opr, val)
TN_Assert_ULong(exp, opr, val)
TN_Assert_Single(exp, opr, val)
TN_Assert_Double(exp, opr, val)
TN_Assert_LongLong(exp, opr, val)
TN_Assert_ULongLong(exp, opr, val)
TN_Assert_LongLong(exp, opr, val)
TN_Assert_ULongLong(exp, opr, val)
TN_Assert_Near(exp, val, err)
TN_Assert_StringEqual(exp, val)
TN_Assert_StringNotEqual(exp, val)
TN_Assert_StringCaseEqual(exp, val)
TN_Assert_StringCaseNotEqual(exp, val)
TN_Assert_Exception(exp)
TN_Assert_NoException(exp)
TN_Assert_Pred1(pred, fmt1, pm1)
TN_Assert_Pred2(pred, fmt1, pm1, fmt2, pm2)
TN_Assert_Pred3(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3)
TN_Assert_Pred4(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3, fmt4, pm4)
TN_Assert_Pred5(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3, fmt4, pm4, fmt5, pm5)
TN_Assert_Pred6(pred, fmt1, pm1, fmt2, pm2, fmt3, pm3, fmt4, pm4, fmt5, pm5, fmt6, pm6)

二、辅助功能

1) 时钟计时器

TN_clock start;

//初始化 - 一个进程中只需初始化一次
TN_clock_init();
//启动计时器
TN_clock_start(&start);
	.....
	.....
//停止计时器
elapsed = TN_clock_elapsed(&start);

2) CPU计时器

TN_timer start;

//初始化 - 一个进程中只需初始化一次
TN_timer_init();
//启动计时器
TN_timer_start(&start);
	.....
	.....
//停止计时器
elapsed = TN_timer_elapsed(&start);

3) 时间函数

char str_buf[64];

TN_time prev;
TN_time now;

// 获取当前本地时间
TN_local_now(&prev);

TN_local_now(&now);

// 返回标准时间字符串
 TN_time_standard(str_buf, sizeof(str_buf), &now);
printf("Current time: %s\n", str_buf);

// 返回格式化时间字符串 - 格式用法同strftime()
TN_time_format(str_buf, sizeof(str_buf), "%d", &now);
printf("Day: %s\n", str_buf);

// 计算时间差 单位：秒
seconds = TN_time_span(&prev, &now);

// struct tm转TN_time
struct tm a;
TN_time b;
TN_from_tm(&b, &a);

// TN_time转struct tm
struct tm a;
TN_time b;
TN_from_tm(&a, &b);

4) 随机数与概率

int main(int argc, char* argv[])
{
	int r;

	// 初始化随机数种子
	TN_srand_now();

	// 获取随机数
	r = TN_rand();

	// 获取范围从100到500的随机数，包含500
	r = TN_random(100, 500);

	// 概率命中测试，概率65%
	if (TN_prob_generator(0.65))
		puts("65% hit");
	else
		puts("65% not hit");

	// 古典概率命中测试，N=2000
	if (TN_prob_generator(TN_make_prob(2000)))
		puts("0.05% hit");
	else
		puts("0.05% not hit");

	return 0;
}

5) 控制台辅助

int main(int argc, char* argv[])
{
	int x, y;
	unsigned short clr;

	TN_console_init();

	// 获取控制台颜色
	clr = TN_console_get_color();

	// 设置控制台前景色为黄色
	TN_console_set_foreground(TN_Yellow);
	puts("Hello! i'm Yellow");

	// 设置控制台背景色为黄色
	TN_console_set_background(TN_Red);
	puts("Oh! my background color change to Red");

	// 获取光标位置
	TN_console_get_position(&x, &y);
	printf("My position is (%d, %d)\n", x, y);

	// 移动光标位置
	printf("I'm going to (%d, %d)\n", x + 3, y + 2);
	TN_console_set_position(x + 3, y + 2);
	printf("It's done\n");

	// 设置控制台颜色
	TN_console_set_color(clr);

	TN_console_term();
	return 0;
}

所有支持的颜色如下：

黑色	TN_Black
深蓝色	TN_DarkBlue
深绿色	TN_DarkGreen
深红色	TN_DarkRed
深灰色	TN_DarkGrey
深黄色	TN_DarkYellow
深紫色	TN_DarkPurple
深青色	TN_DarkCyan
灰色	TN_Grey
蓝色	TN_Blue
绿色	TN_Green
红色	TN_Red
白色	TN_White
黄色	TN_Yellow
紫色	TN_Purple
青色	TN_Cyan

6) 线程辅助

TN_lock lock;

// 创建线程锁
TN_local_lock_create(&lock);

// 锁
TN_local_lock(&lock);

.......

// 切出当前线程
TN_local_switch();

.......

// 当前线程睡眠1秒钟
TN_local_sleep(1000);

.......

// 解锁
TN_local_unlock(&lock);

// 销毁线程锁
TN_local_lock_destroy(&lock);