一个用于 C 语言的测试库
Snow is a header-only unit testing library for C. Just include the file snow/snow.h.
IRC channel: #snow on Freenode. If you have any questions, or just want to chat, just ping me (@mort) :)
Snow 2 is a complete rewrite of Snow. Here are the highlights:
describe(foo, { ... }))
to outside of macro arguments (i.e describe(foo) { ... }). This applies to
describe, subdesc, it/test, before_each, and after_each.asserteq and assertneq works slightly differently, but most code which
worked before should continue to work.asserteq(foo, bar, "Some explanation").Some miscellaneous points:
asserteq and assertneq macros require
C11.-DSNOW_USE_FNMATCH=1 or -DSNOW_USE_FNMATCH=0.
Gnulib
implements fnmatch, and supports Windows under Cygwin.When creating the main function using the snow_main macro, your executable
will take these arguments. The --no- prefixed arguments will disable the
relevant function:
\r after maybe messages instead of \n. This
will override them with successes or failures as they are printed out.
Default: on when output is a TTY, off otherwise.Here's a simple example which tests a couple of filesystem functions, and has a subdescription for testing fread-related stuff.
gcc -Isnow -DSNOW_ENABLED -g -o test example.c-Isnow: add snow to our include path, to make #include
work. (That assumes snow/snow/snow.h exists, like if you clone this repo.)-DSNOW_ENABLED: Enable snow (otherwise describe(...) would be
compiled down to nothing).-g: Add debug symbols for valgrind.valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --error-exitcode=1 ./test…A top-level description of a component, which can contain subdescs and its.
A describe(testname, block) will define a function void test_##testname(),
which the main function created by snow_main will call automatically.
A description of a sub-component, which can contain nested subdescs and
its. It's similar to describe, but doesn't define a function.
A particular test case. It can contain asserts and defers, as well as just
regular code. A failing assert (or direct call to fail(...)) will mark the
test as failed, but if it completes normally, it's marked as successful.
test(description) is an alias, for cases where using it would read
awkwardly.
defer is used for tearing down, and is inspired by Go's defer
statement.
Once the test case completes, each deferred expression will be executed, in the
reverse order of their definitions (i.e defer(printf("World")); defer(printf("Hello ")); will print "Hello World"). If the test case fails,
only deferred expressions defined before the point of failure will be executed.
Code to run before each test case.
Code to run after each test case.
This macro expands to a main function which handless stuff like parsing arguments and freeing memory allocated by Snow. All described functions will automatically be called by the main functions.
If you want more control over the main function, you can use the
snow_main_decls macro to create the necessary global variables and functions,
and then call the snow_main_function(int argc, char **argv) function.
This is essentially how snow_main() works:
snow_main_decls;
int main(int argc, char **argv) {
return snow_main_function(argc, argv);
}Just directly fail the test case. The arguments are a printf-style format,
optionally followed by arguments, just like printf.
Fail if the expression x returns 0. explanation is an optional string
which will be printed if the assertion fails, and can be used to provide some
context.
Fail unless a equals b. If b is a string, strcmp will be used to check
for equality; otherwise, == will be used.
asserteq requires C11.
If you can't use C11, or want to explicitly state what type your arguments are
(say you want to compare strings by pointer instead of by content), you
can use the asserteq_int, asserteq_ptr, asserteq_dbl, and asserteq_str
macros instead of asserteq.
Fail if a equals b. If b is a string, strcmp will be used to check
for equality; otherwise, == will be used.
assertneq requires C11.
If you can't use C11, or want to explicitly state what type your arguments are
(say you want to compare strings by pointer instead of by content), you
can use the assertneq_int, assertneq_ptr, assertneq_dbl, and asserteq_str
macros instead of assertneq.
Fail unless the first n bytes of a and b are the same.
Fail if the first n bytes of a and b are the same.
snow_fail_update saves the current file/line, while snow_fail fails the
currently executing test case and prints the saved file/line from the last
snow_fail_update. This allows for implementing new checks to fail tests.
All assertion functions from Snow are implemented using snow_fail and
snow_fail_update.
Exactly how to test your code might not be as obvious with C as it is for other languages. I haven't yet used Snow for any big projects, but here's how I would do it
When testing a library's interface, you can just create a test folder which
is completely decoupled from the library's source code, and just compile your
test code with a flag to link against your library.
Testing anything that's not exposed as a library's public API is is possible
because unless SNOW_ENABLED is defined, describe will just be an empty
macro, and all uses of it will be removed by the preprocessor. Therfore, you
can include tests directly in your C source files, and regular builds won't
use snow, while builds with -DSNOW_ENABLED will be your test suite.
Since all test macros are compiled down to nothing, this will have no runtime performance or binary size impact.
Note that since snow.h defines macros with pretty general names (it,
describe, assert), it's probably a good idea to put your tests at the
bottom of the source and only include snow.h right above the test code, to
avoid name conflicts.
The exampleproject directory is an example of a program tested this way.
暂无开放 Issues,或尚未同步最近议题。