kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

t/unit-tests: convert strvec tests to use clar 

Convert the strvec tests to use the new clar unit testing framework.
This is a first test balloon that demonstrates how the testing infra for
clar-based tests looks like.

The tests are part of the "t/unit-tests/bin/unit-tests" binary. When
running that binary with an injected error, it generates TAP output:

    # ./t/unit-tests/bin/unit-tests
    TAP version 13
    # start of suite 1: strvec
    ok 1 - strvec::init
    ok 2 - strvec::dynamic_init
    ok 3 - strvec::clear
    not ok 4 - strvec::push
        ---
        reason: |
          String mismatch: (&vec)->v[i] != expect[i]
          'foo' != 'fo' (at byte 2)
        at:
          file: 't/unit-tests/strvec.c'
          line: 48
          function: 'test_strvec__push'
        ---
    ok 5 - strvec::pushf
    ok 6 - strvec::pushl
    ok 7 - strvec::pushv
    ok 8 - strvec::replace_at_head
    ok 9 - strvec::replace_at_tail
    ok 10 - strvec::replace_in_between
    ok 11 - strvec::replace_with_substring
    ok 12 - strvec::remove_at_head
    ok 13 - strvec::remove_at_tail
    ok 14 - strvec::remove_in_between
    ok 15 - strvec::pop_empty_array
    ok 16 - strvec::pop_non_empty_array
    ok 17 - strvec::split_empty_string
    ok 18 - strvec::split_single_item
    ok 19 - strvec::split_multiple_items
    ok 20 - strvec::split_whitespace_only
    ok 21 - strvec::split_multiple_consecutive_whitespaces
    ok 22 - strvec::detach
    1..22

The binary also supports some parameters that allow us to run only a
subset of unit tests or alter the output:

    $ ./t/unit-tests/bin/unit-tests -h
    Usage: ./t/unit-tests/bin/unit-tests [options]

    Options:
      -sname        Run only the suite with `name` (can go to individual test name)
      -iname        Include the suite with `name`
      -xname        Exclude the suite with `name`
      -v            Increase verbosity (show suite names)
      -q            Only report tests that had an error
      -Q            Quit as soon as a test fails
      -t            Display results in tap format
      -l            Print suite names
      -r[filename]  Write summary file (to the optional filename)

Furthermore, running `make unit-tests` runs the binary along with all
the other unit tests we have.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Patrick Steinhardt 2024-09-04 16:17:17 +02:00 committed by Junio C Hamano
parent 3d5d4c876a
commit d7f0c47964
3 changed files with 242 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -1336,6 +1336,7 @@ THIRD_PARTY_SOURCES += sha1dc/%
THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/%
THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/clar/%

UNIT_TESTS_SUITES += strvec
UNIT_TESTS_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)
UNIT_TESTS_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(UNIT_TESTS_SUITES))
UNIT_TESTS_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
@ -1356,7 +1357,6 @@ UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-tree
UNIT_TEST_PROGRAMS += t-strbuf
UNIT_TEST_PROGRAMS += t-strcmp-offset
UNIT_TEST_PROGRAMS += t-strvec
UNIT_TEST_PROGRAMS += t-trailer
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
UNIT_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(UNIT_TEST_PROGRAMS))

241
t/unit-tests/strvec.c Normal file
View File

@ -0,0 +1,241 @@
#include "unit-test.h"
#include "strbuf.h"
#include "strvec.h"

#define check_strvec(vec, ...) \
do { \
const char *expect[] = { __VA_ARGS__ }; \
size_t expect_len = ARRAY_SIZE(expect); \
cl_assert(expect_len > 0); \
cl_assert_equal_p(expect[expect_len - 1], NULL); \
cl_assert_equal_i((vec)->nr, expect_len - 1); \
cl_assert((vec)->nr <= (vec)->alloc); \
for (size_t i = 0; i < expect_len; i++) \
cl_assert_equal_s((vec)->v[i], expect[i]); \
} while (0)

void test_strvec__init(void)
{
struct strvec vec = STRVEC_INIT;

cl_assert_equal_p(vec.v, empty_strvec);
cl_assert_equal_i(vec.nr, 0);
cl_assert_equal_i(vec.alloc, 0);
}

void test_strvec__dynamic_init(void)
{
struct strvec vec;

strvec_init(&vec);
cl_assert_equal_p(vec.v, empty_strvec);
cl_assert_equal_i(vec.nr, 0);
cl_assert_equal_i(vec.alloc, 0);
}

void test_strvec__clear(void)
{
struct strvec vec = STRVEC_INIT;

strvec_push(&vec, "foo");
strvec_clear(&vec);
cl_assert_equal_p(vec.v, empty_strvec);
cl_assert_equal_i(vec.nr, 0);
cl_assert_equal_i(vec.alloc, 0);
}

void test_strvec__push(void)
{
struct strvec vec = STRVEC_INIT;

strvec_push(&vec, "foo");
check_strvec(&vec, "foo", NULL);

strvec_push(&vec, "bar");
check_strvec(&vec, "foo", "bar", NULL);

strvec_clear(&vec);
}

void test_strvec__pushf(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushf(&vec, "foo: %d", 1);
check_strvec(&vec, "foo: 1", NULL);
strvec_clear(&vec);
}

void test_strvec__pushl(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
check_strvec(&vec, "foo", "bar", "baz", NULL);
strvec_clear(&vec);
}

void test_strvec__pushv(void)
{
const char *strings[] = {
"foo", "bar", "baz", NULL,
};
struct strvec vec = STRVEC_INIT;

strvec_pushv(&vec, strings);
check_strvec(&vec, "foo", "bar", "baz", NULL);

strvec_clear(&vec);
}

void test_strvec__replace_at_head(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_replace(&vec, 0, "replaced");
check_strvec(&vec, "replaced", "bar", "baz", NULL);
strvec_clear(&vec);
}

void test_strvec__replace_at_tail(void)
{
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_replace(&vec, 2, "replaced");
check_strvec(&vec, "foo", "bar", "replaced", NULL);
strvec_clear(&vec);
}

void test_strvec__replace_in_between(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_replace(&vec, 1, "replaced");
check_strvec(&vec, "foo", "replaced", "baz", NULL);
strvec_clear(&vec);
}

void test_strvec__replace_with_substring(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", NULL);
strvec_replace(&vec, 0, vec.v[0] + 1);
check_strvec(&vec, "oo", NULL);
strvec_clear(&vec);
}

void test_strvec__remove_at_head(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_remove(&vec, 0);
check_strvec(&vec, "bar", "baz", NULL);
strvec_clear(&vec);
}

void test_strvec__remove_at_tail(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_remove(&vec, 2);
check_strvec(&vec, "foo", "bar", NULL);
strvec_clear(&vec);
}

void test_strvec__remove_in_between(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_remove(&vec, 1);
check_strvec(&vec, "foo", "baz", NULL);
strvec_clear(&vec);
}

void test_strvec__pop_empty_array(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pop(&vec);
check_strvec(&vec, NULL);
strvec_clear(&vec);
}

void test_strvec__pop_non_empty_array(void)
{
struct strvec vec = STRVEC_INIT;

strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_pop(&vec);
check_strvec(&vec, "foo", "bar", NULL);
strvec_clear(&vec);
}

void test_strvec__split_empty_string(void)
{
struct strvec vec = STRVEC_INIT;

strvec_split(&vec, "");
check_strvec(&vec, NULL);
strvec_clear(&vec);
}

void test_strvec__split_single_item(void)
{
struct strvec vec = STRVEC_INIT;

strvec_split(&vec, "foo");
check_strvec(&vec, "foo", NULL);
strvec_clear(&vec);
}

void test_strvec__split_multiple_items(void)
{
struct strvec vec = STRVEC_INIT;

strvec_split(&vec, "foo bar baz");
check_strvec(&vec, "foo", "bar", "baz", NULL);
strvec_clear(&vec);
}

void test_strvec__split_whitespace_only(void)
{
struct strvec vec = STRVEC_INIT;

strvec_split(&vec, " \t\n");
check_strvec(&vec, NULL);
strvec_clear(&vec);
}

void test_strvec__split_multiple_consecutive_whitespaces(void)
{
struct strvec vec = STRVEC_INIT;

strvec_split(&vec, "foo\n\t bar");
check_strvec(&vec, "foo", "bar", NULL);
strvec_clear(&vec);
}

void test_strvec__detach(void)
{
struct strvec vec = STRVEC_INIT;
const char **detached;

strvec_push(&vec, "foo");

detached = strvec_detach(&vec);
cl_assert_equal_s(detached[0], "foo");
cl_assert_equal_p(detached[1], NULL);

cl_assert_equal_p(vec.v, empty_strvec);
cl_assert_equal_i(vec.nr, 0);
cl_assert_equal_i(vec.alloc, 0);

free((char *) detached[0]);
free(detached);
}

211
t/unit-tests/t-strvec.c
View File

@ -1,211 +0,0 @@
#include "test-lib.h"
#include "strbuf.h"
#include "strvec.h"

#define check_strvec(vec, ...) \
do { \
const char *expect[] = { __VA_ARGS__ }; \
if (check_uint(ARRAY_SIZE(expect), >, 0) && \
check_pointer_eq(expect[ARRAY_SIZE(expect) - 1], NULL) && \
check_uint((vec)->nr, ==, ARRAY_SIZE(expect) - 1) && \
check_uint((vec)->nr, <=, (vec)->alloc)) { \
for (size_t i = 0; i < ARRAY_SIZE(expect); i++) { \
if (!check_str((vec)->v[i], expect[i])) { \
test_msg(" i: %"PRIuMAX, \
(uintmax_t)i); \
break; \
} \
} \
} \
} while (0)

int cmd_main(int argc, const char **argv)
{
if_test ("static initialization") {
struct strvec vec = STRVEC_INIT;
check_pointer_eq(vec.v, empty_strvec);
check_uint(vec.nr, ==, 0);
check_uint(vec.alloc, ==, 0);
}

if_test ("dynamic initialization") {
struct strvec vec;
strvec_init(&vec);
check_pointer_eq(vec.v, empty_strvec);
check_uint(vec.nr, ==, 0);
check_uint(vec.alloc, ==, 0);
}

if_test ("clear") {
struct strvec vec = STRVEC_INIT;
strvec_push(&vec, "foo");
strvec_clear(&vec);
check_pointer_eq(vec.v, empty_strvec);
check_uint(vec.nr, ==, 0);
check_uint(vec.alloc, ==, 0);
}

if_test ("push") {
struct strvec vec = STRVEC_INIT;

strvec_push(&vec, "foo");
check_strvec(&vec, "foo", NULL);

strvec_push(&vec, "bar");
check_strvec(&vec, "foo", "bar", NULL);

strvec_clear(&vec);
}

if_test ("pushf") {
struct strvec vec = STRVEC_INIT;
strvec_pushf(&vec, "foo: %d", 1);
check_strvec(&vec, "foo: 1", NULL);
strvec_clear(&vec);
}

if_test ("pushl") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
check_strvec(&vec, "foo", "bar", "baz", NULL);
strvec_clear(&vec);
}

if_test ("pushv") {
const char *strings[] = {
"foo", "bar", "baz", NULL,
};
struct strvec vec = STRVEC_INIT;

strvec_pushv(&vec, strings);
check_strvec(&vec, "foo", "bar", "baz", NULL);

strvec_clear(&vec);
}

if_test ("replace at head") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_replace(&vec, 0, "replaced");
check_strvec(&vec, "replaced", "bar", "baz", NULL);
strvec_clear(&vec);
}

if_test ("replace at tail") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_replace(&vec, 2, "replaced");
check_strvec(&vec, "foo", "bar", "replaced", NULL);
strvec_clear(&vec);
}

if_test ("replace in between") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_replace(&vec, 1, "replaced");
check_strvec(&vec, "foo", "replaced", "baz", NULL);
strvec_clear(&vec);
}

if_test ("replace with substring") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", NULL);
strvec_replace(&vec, 0, vec.v[0] + 1);
check_strvec(&vec, "oo", NULL);
strvec_clear(&vec);
}

if_test ("remove at head") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_remove(&vec, 0);
check_strvec(&vec, "bar", "baz", NULL);
strvec_clear(&vec);
}

if_test ("remove at tail") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_remove(&vec, 2);
check_strvec(&vec, "foo", "bar", NULL);
strvec_clear(&vec);
}

if_test ("remove in between") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_remove(&vec, 1);
check_strvec(&vec, "foo", "baz", NULL);
strvec_clear(&vec);
}

if_test ("pop with empty array") {
struct strvec vec = STRVEC_INIT;
strvec_pop(&vec);
check_strvec(&vec, NULL);
strvec_clear(&vec);
}

if_test ("pop with non-empty array") {
struct strvec vec = STRVEC_INIT;
strvec_pushl(&vec, "foo", "bar", "baz", NULL);
strvec_pop(&vec);
check_strvec(&vec, "foo", "bar", NULL);
strvec_clear(&vec);
}

if_test ("split empty string") {
struct strvec vec = STRVEC_INIT;
strvec_split(&vec, "");
check_strvec(&vec, NULL);
strvec_clear(&vec);
}

if_test ("split single item") {
struct strvec vec = STRVEC_INIT;
strvec_split(&vec, "foo");
check_strvec(&vec, "foo", NULL);
strvec_clear(&vec);
}

if_test ("split multiple items") {
struct strvec vec = STRVEC_INIT;
strvec_split(&vec, "foo bar baz");
check_strvec(&vec, "foo", "bar", "baz", NULL);
strvec_clear(&vec);
}

if_test ("split whitespace only") {
struct strvec vec = STRVEC_INIT;
strvec_split(&vec, " \t\n");
check_strvec(&vec, NULL);
strvec_clear(&vec);
}

if_test ("split multiple consecutive whitespaces") {
struct strvec vec = STRVEC_INIT;
strvec_split(&vec, "foo\n\t bar");
check_strvec(&vec, "foo", "bar", NULL);
strvec_clear(&vec);
}

if_test ("detach") {
struct strvec vec = STRVEC_INIT;
const char **detached;

strvec_push(&vec, "foo");

detached = strvec_detach(&vec);
check_str(detached[0], "foo");
check_pointer_eq(detached[1], NULL);

check_pointer_eq(vec.v, empty_strvec);
check_uint(vec.nr, ==, 0);
check_uint(vec.alloc, ==, 0);

free((char *) detached[0]);
free(detached);
}

return test_done();
}