mirror of
https://github.com/git/git
synced 2024-09-13 21:34:42 +00:00
e137fe3b29
This patch contains an implementation for writing unit tests with TAP
output. Each test is a function that contains one or more checks. The
test is run with the TEST() macro and if any of the checks fail then the
test will fail. A complete program that tests STRBUF_INIT would look
like
#include "test-lib.h"
#include "strbuf.h"
static void t_static_init(void)
{
struct strbuf buf = STRBUF_INIT;
check_uint(buf.len, ==, 0);
check_uint(buf.alloc, ==, 0);
check_char(buf.buf[0], ==, '\0');
}
int main(void)
{
TEST(t_static_init(), "static initialization works);
return test_done();
}
The output of this program would be
ok 1 - static initialization works
1..1
If any of the checks in a test fail then they print a diagnostic message
to aid debugging and the test will be reported as failing. For example a
failing integer check would look like
# check "x >= 3" failed at my-test.c:102
# left: 2
# right: 3
not ok 1 - x is greater than or equal to three
There are a number of check functions implemented so far. check() checks
a boolean condition, check_int(), check_uint() and check_char() take two
values to compare and a comparison operator. check_str() will check if
two strings are equal. Custom checks are simple to implement as shown in
the comments above test_assert() in test-lib.h.
Tests can be skipped with test_skip() which can be supplied with a
reason for skipping which it will print. Tests can print diagnostic
messages with test_msg(). Checks that are known to fail can be wrapped
in TEST_TODO().
There are a couple of example test programs included in this
patch. t-basic.c implements some self-tests and demonstrates the
diagnostic output for failing test. The output of this program is
checked by t0080-unit-test-output.sh. t-strbuf.c shows some example
unit tests for strbuf.c
The unit tests will be built as part of the default "make all" target,
to avoid bitrot. If you wish to build just the unit tests, you can run
"make build-unit-tests". To run the tests, you can use "make unit-tests"
or run the test binaries directly, as in "./t/unit-tests/bin/t-strbuf".
Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
Signed-off-by: Josh Steadmon <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
121 lines
3.2 KiB
C
121 lines
3.2 KiB
C
#include "test-lib.h"
|
|
#include "strbuf.h"
|
|
|
|
/* wrapper that supplies tests with an empty, initialized strbuf */
|
|
static void setup(void (*f)(struct strbuf*, void*), void *data)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
f(&buf, data);
|
|
strbuf_release(&buf);
|
|
check_uint(buf.len, ==, 0);
|
|
check_uint(buf.alloc, ==, 0);
|
|
}
|
|
|
|
/* wrapper that supplies tests with a populated, initialized strbuf */
|
|
static void setup_populated(void (*f)(struct strbuf*, void*), char *init_str, void *data)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_addstr(&buf, init_str);
|
|
check_uint(buf.len, ==, strlen(init_str));
|
|
f(&buf, data);
|
|
strbuf_release(&buf);
|
|
check_uint(buf.len, ==, 0);
|
|
check_uint(buf.alloc, ==, 0);
|
|
}
|
|
|
|
static int assert_sane_strbuf(struct strbuf *buf)
|
|
{
|
|
/* Initialized strbufs should always have a non-NULL buffer */
|
|
if (!check(!!buf->buf))
|
|
return 0;
|
|
/* Buffers should always be NUL-terminated */
|
|
if (!check_char(buf->buf[buf->len], ==, '\0'))
|
|
return 0;
|
|
/*
|
|
* Freshly-initialized strbufs may not have a dynamically allocated
|
|
* buffer
|
|
*/
|
|
if (buf->len == 0 && buf->alloc == 0)
|
|
return 1;
|
|
/* alloc must be at least one byte larger than len */
|
|
return check_uint(buf->len, <, buf->alloc);
|
|
}
|
|
|
|
static void t_static_init(void)
|
|
{
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
check_uint(buf.len, ==, 0);
|
|
check_uint(buf.alloc, ==, 0);
|
|
check_char(buf.buf[0], ==, '\0');
|
|
}
|
|
|
|
static void t_dynamic_init(void)
|
|
{
|
|
struct strbuf buf;
|
|
|
|
strbuf_init(&buf, 1024);
|
|
check(assert_sane_strbuf(&buf));
|
|
check_uint(buf.len, ==, 0);
|
|
check_uint(buf.alloc, >=, 1024);
|
|
check_char(buf.buf[0], ==, '\0');
|
|
strbuf_release(&buf);
|
|
}
|
|
|
|
static void t_addch(struct strbuf *buf, void *data)
|
|
{
|
|
const char *p_ch = data;
|
|
const char ch = *p_ch;
|
|
size_t orig_alloc = buf->alloc;
|
|
size_t orig_len = buf->len;
|
|
|
|
if (!check(assert_sane_strbuf(buf)))
|
|
return;
|
|
strbuf_addch(buf, ch);
|
|
if (!check(assert_sane_strbuf(buf)))
|
|
return;
|
|
if (!(check_uint(buf->len, ==, orig_len + 1) &&
|
|
check_uint(buf->alloc, >=, orig_alloc)))
|
|
return; /* avoid de-referencing buf->buf */
|
|
check_char(buf->buf[buf->len - 1], ==, ch);
|
|
check_char(buf->buf[buf->len], ==, '\0');
|
|
}
|
|
|
|
static void t_addstr(struct strbuf *buf, void *data)
|
|
{
|
|
const char *text = data;
|
|
size_t len = strlen(text);
|
|
size_t orig_alloc = buf->alloc;
|
|
size_t orig_len = buf->len;
|
|
|
|
if (!check(assert_sane_strbuf(buf)))
|
|
return;
|
|
strbuf_addstr(buf, text);
|
|
if (!check(assert_sane_strbuf(buf)))
|
|
return;
|
|
if (!(check_uint(buf->len, ==, orig_len + len) &&
|
|
check_uint(buf->alloc, >=, orig_alloc) &&
|
|
check_uint(buf->alloc, >, orig_len + len) &&
|
|
check_char(buf->buf[orig_len + len], ==, '\0')))
|
|
return;
|
|
check_str(buf->buf + orig_len, text);
|
|
}
|
|
|
|
int cmd_main(int argc, const char **argv)
|
|
{
|
|
if (!TEST(t_static_init(), "static initialization works"))
|
|
test_skip_all("STRBUF_INIT is broken");
|
|
TEST(t_dynamic_init(), "dynamic initialization works");
|
|
TEST(setup(t_addch, "a"), "strbuf_addch adds char");
|
|
TEST(setup(t_addch, ""), "strbuf_addch adds NUL char");
|
|
TEST(setup_populated(t_addch, "initial value", "a"),
|
|
"strbuf_addch appends to initial value");
|
|
TEST(setup(t_addstr, "hello there"), "strbuf_addstr adds string");
|
|
TEST(setup_populated(t_addstr, "initial value", "hello there"),
|
|
"strbuf_addstr appends string to initial value");
|
|
|
|
return test_done();
|
|
}
|