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

Merge branch 'sk/unit-tests-0130' 

Convert a handful of unit tests to work with the clar framework.

* sk/unit-tests-0130:
  t/unit-tests: convert strcmp-offset test to use clar test framework
  t/unit-tests: convert strbuf test to use clar test framework
  t/unit-tests: adapt example decorate test to use clar test framework
  t/unit-tests: convert hashmap test to use clar test framework
maint
Junio C Hamano 2025-02-10 10:18:31 -08:00
parent 246569bf83 af8bf677c1
commit 6f0b72205d
9 changed files with 348 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Makefile
View File

@ -1342,18 +1342,20 @@ THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/%
THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/clar/%

CLAR_TEST_SUITES += u-ctype
CLAR_TEST_SUITES += u-example-decorate
CLAR_TEST_SUITES += u-hash
CLAR_TEST_SUITES += u-hashmap
CLAR_TEST_SUITES += u-mem-pool
CLAR_TEST_SUITES += u-prio-queue
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
CLAR_TEST_SUITES += u-strvec
CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)
CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o

UNIT_TEST_PROGRAMS += t-example-decorate
UNIT_TEST_PROGRAMS += t-hashmap
UNIT_TEST_PROGRAMS += t-oid-array
UNIT_TEST_PROGRAMS += t-oidmap
UNIT_TEST_PROGRAMS += t-oidtree
@ -1365,8 +1367,6 @@ UNIT_TEST_PROGRAMS += t-reftable-reader
UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
UNIT_TEST_PROGRAMS += t-strbuf
UNIT_TEST_PROGRAMS += t-strcmp-offset
UNIT_TEST_PROGRAMS += t-trailer
UNIT_TEST_PROGRAMS += t-urlmatch-normalization
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))

8
t/meson.build
View File

@ -1,9 +1,13 @@
clar_test_suites = [
'unit-tests/u-ctype.c',
'unit-tests/u-example-decorate.c',
'unit-tests/u-hash.c',
'unit-tests/u-hashmap.c',
'unit-tests/u-mem-pool.c',
'unit-tests/u-prio-queue.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
'unit-tests/u-strvec.c',
]

@ -44,8 +48,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)

unit_test_programs = [
'unit-tests/t-example-decorate.c',
'unit-tests/t-hashmap.c',
'unit-tests/t-oid-array.c',
'unit-tests/t-oidmap.c',
'unit-tests/t-oidtree.c',
@ -57,8 +59,6 @@ unit_test_programs = [
'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c',
'unit-tests/t-strbuf.c',
'unit-tests/t-strcmp-offset.c',
'unit-tests/t-trailer.c',
'unit-tests/t-urlmatch-normalization.c',
]

74
t/unit-tests/t-example-decorate.c
View File

@ -1,74 +0,0 @@
#define USE_THE_REPOSITORY_VARIABLE

#include "test-lib.h"
#include "object.h"
#include "decorate.h"
#include "repository.h"

struct test_vars {
struct object *one, *two, *three;
struct decoration n;
int decoration_a, decoration_b;
};

static void t_add(struct test_vars *vars)
{
void *ret = add_decoration(&vars->n, vars->one, &vars->decoration_a);

check(ret == NULL);
ret = add_decoration(&vars->n, vars->two, NULL);
check(ret == NULL);
}

static void t_readd(struct test_vars *vars)
{
void *ret = add_decoration(&vars->n, vars->one, NULL);

check(ret == &vars->decoration_a);
ret = add_decoration(&vars->n, vars->two, &vars->decoration_b);
check(ret == NULL);
}

static void t_lookup(struct test_vars *vars)
{
void *ret = lookup_decoration(&vars->n, vars->one);

check(ret == NULL);
ret = lookup_decoration(&vars->n, vars->two);
check(ret == &vars->decoration_b);
ret = lookup_decoration(&vars->n, vars->three);
check(ret == NULL);
}

static void t_loop(struct test_vars *vars)
{
int objects_noticed = 0;

for (size_t i = 0; i < vars->n.size; i++) {
if (vars->n.entries[i].base)
objects_noticed++;
}
check_int(objects_noticed, ==, 2);
}

int cmd_main(int argc UNUSED, const char **argv UNUSED)
{
struct object_id one_oid = { { 1 } }, two_oid = { { 2 } }, three_oid = { { 3 } };
struct test_vars vars = { 0 };

vars.one = lookup_unknown_object(the_repository, &one_oid);
vars.two = lookup_unknown_object(the_repository, &two_oid);
vars.three = lookup_unknown_object(the_repository, &three_oid);

TEST(t_add(&vars),
"Add 2 objects, one with a non-NULL decoration and one with a NULL decoration.");
TEST(t_readd(&vars),
"When re-adding an already existing object, the old decoration is returned.");
TEST(t_lookup(&vars),
"Lookup returns the added declarations, or NULL if the object was never added.");
TEST(t_loop(&vars), "The user can also loop through all entries.");

clear_decoration(&vars.n, NULL);

return test_done();
}

122
t/unit-tests/t-strbuf.c
View File

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

/* wrapper that supplies tests with an empty, initialized strbuf */
static void setup(void (*f)(struct strbuf*, const void*),
const 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*, const void*),
const char *init_str, const 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, const 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, const 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 UNUSED, const char **argv UNUSED)
{
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();
}

35
t/unit-tests/t-strcmp-offset.c
View File

@ -1,35 +0,0 @@
#include "test-lib.h"
#include "read-cache-ll.h"

static void check_strcmp_offset(const char *string1, const char *string2,
int expect_result, uintmax_t expect_offset)
{
size_t offset;
int result = strcmp_offset(string1, string2, &offset);

/*
* Because different CRTs behave differently, only rely on signs of the
* result values.
*/
result = (result < 0 ? -1 :
result > 0 ? 1 :
0);

check_int(result, ==, expect_result);
check_uint((uintmax_t)offset, ==, expect_offset);
}

#define TEST_STRCMP_OFFSET(string1, string2, expect_result, expect_offset) \
TEST(check_strcmp_offset(string1, string2, expect_result, \
expect_offset), \
"strcmp_offset(%s, %s) works", #string1, #string2)

int cmd_main(int argc UNUSED, const char **argv UNUSED)
{
TEST_STRCMP_OFFSET("abc", "abc", 0, 3);
TEST_STRCMP_OFFSET("abc", "def", -1, 0);
TEST_STRCMP_OFFSET("abc", "abz", -1, 2);
TEST_STRCMP_OFFSET("abc", "abcdef", -1, 3);

return test_done();
}

64
t/unit-tests/u-example-decorate.c Normal file
View File

@ -0,0 +1,64 @@
#define USE_THE_REPOSITORY_VARIABLE

#include "unit-test.h"
#include "object.h"
#include "decorate.h"
#include "repository.h"

struct test_vars {
struct object *one, *two, *three;
struct decoration n;
int decoration_a, decoration_b;
};

static struct test_vars vars;

void test_example_decorate__initialize(void)
{
struct object_id one_oid = { { 1 } }, two_oid = { { 2 } }, three_oid = { { 3 } };

vars.one = lookup_unknown_object(the_repository, &one_oid);
vars.two = lookup_unknown_object(the_repository, &two_oid);
vars.three = lookup_unknown_object(the_repository, &three_oid);
}

void test_example_decorate__cleanup(void)
{
clear_decoration(&vars.n, NULL);
}

void test_example_decorate__add(void)
{
cl_assert_equal_p(add_decoration(&vars.n, vars.one, &vars.decoration_a), NULL);
cl_assert_equal_p(add_decoration(&vars.n, vars.two, NULL), NULL);
}

void test_example_decorate__readd(void)
{
cl_assert_equal_p(add_decoration(&vars.n, vars.one, &vars.decoration_a), NULL);
cl_assert_equal_p(add_decoration(&vars.n, vars.two, NULL), NULL);
cl_assert_equal_p(add_decoration(&vars.n, vars.one, NULL), &vars.decoration_a);
cl_assert_equal_p(add_decoration(&vars.n, vars.two, &vars.decoration_b), NULL);
}

void test_example_decorate__lookup(void)
{
cl_assert_equal_p(add_decoration(&vars.n, vars.two, &vars.decoration_b), NULL);
cl_assert_equal_p(add_decoration(&vars.n, vars.one, NULL), NULL);
cl_assert_equal_p(lookup_decoration(&vars.n, vars.two), &vars.decoration_b);
cl_assert_equal_p(lookup_decoration(&vars.n, vars.one), NULL);
}

void test_example_decorate__loop(void)
{
int objects_noticed = 0;

cl_assert_equal_p(add_decoration(&vars.n, vars.one, &vars.decoration_a), NULL);
cl_assert_equal_p(add_decoration(&vars.n, vars.two, &vars.decoration_b), NULL);

for (size_t i = 0; i < vars.n.size; i++)
if (vars.n.entries[i].base)
objects_noticed++;

cl_assert_equal_i(objects_noticed, 2);
}

226
t/unit-tests/t-hashmap.c → t/unit-tests/u-hashmap.c
View File

@ -1,4 +1,4 @@
#include "test-lib.h"
#include "unit-test.h"
#include "hashmap.h"
#include "strbuf.h"

@ -83,23 +83,23 @@ static void t_replace(struct hashmap *map, unsigned int ignore_case)
struct test_entry *entry;

entry = alloc_test_entry("key1", "value1", ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);

entry = alloc_test_entry(ignore_case ? "Key1" : "key1", "value2",
ignore_case);
entry = hashmap_put_entry(map, entry, ent);
if (check(entry != NULL))
check_str(get_value(entry), "value1");
cl_assert(entry != NULL);
cl_assert_equal_s(get_value(entry), "value1");
free(entry);

entry = alloc_test_entry("fooBarFrotz", "value3", ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);

entry = alloc_test_entry(ignore_case ? "FOObarFrotz" : "fooBarFrotz",
"value4", ignore_case);
entry = hashmap_put_entry(map, entry, ent);
if (check(entry != NULL))
check_str(get_value(entry), "value3");
cl_assert(entry != NULL);
cl_assert_equal_s(get_value(entry), "value3");
free(entry);
}

@ -122,20 +122,18 @@ static void t_get(struct hashmap *map, unsigned int ignore_case)
for (size_t i = 0; i < ARRAY_SIZE(key_val); i++) {
entry = alloc_test_entry(key_val[i][0], key_val[i][1],
ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);
}

for (size_t i = 0; i < ARRAY_SIZE(query); i++) {
entry = get_test_entry(map, query[i][0], ignore_case);
if (check(entry != NULL))
check_str(get_value(entry), query[i][1]);
else
test_msg("query key: %s", query[i][0]);
cl_assert(entry != NULL);
cl_assert_equal_s(get_value(entry), query[i][1]);
}

check_pointer_eq(get_test_entry(map, "notInMap", ignore_case), NULL);
check_int(map->tablesize, ==, 64);
check_int(hashmap_get_size(map), ==, ARRAY_SIZE(key_val));
cl_assert_equal_p(get_test_entry(map, "notInMap", ignore_case), NULL);
cl_assert_equal_i(map->tablesize, 64);
cl_assert_equal_i(hashmap_get_size(map), ARRAY_SIZE(key_val));
}

static void t_add(struct hashmap *map, unsigned int ignore_case)
@ -165,39 +163,19 @@ static void t_add(struct hashmap *map, unsigned int ignore_case)

hashmap_for_each_entry_from(map, entry, ent)
{
int ret;
if (!check_int((ret = key_val_contains(
key_val, seen,
ARRAY_SIZE(key_val), entry)),
==, 0)) {
switch (ret) {
case 1:
test_msg("found entry was not given in the input\n"
" key: %s\n value: %s",
entry->key, get_value(entry));
break;
case 2:
test_msg("duplicate entry detected\n"
" key: %s\n value: %s",
entry->key, get_value(entry));
break;
}
} else {
count++;
}
int ret = key_val_contains(key_val, seen,
ARRAY_SIZE(key_val), entry);
cl_assert_equal_i(ret, 0);
count++;
}
check_int(count, ==, 2);
cl_assert_equal_i(count, 2);
}

for (size_t i = 0; i < ARRAY_SIZE(seen); i++) {
if (!check_int(seen[i], ==, 1))
test_msg("following key-val pair was not iterated over:\n"
" key: %s\n value: %s",
key_val[i][0], key_val[i][1]);
}
for (size_t i = 0; i < ARRAY_SIZE(seen); i++)
cl_assert_equal_i(seen[i], 1);

check_int(hashmap_get_size(map), ==, ARRAY_SIZE(key_val));
check_pointer_eq(get_test_entry(map, "notInMap", ignore_case), NULL);
cl_assert_equal_i(hashmap_get_size(map), ARRAY_SIZE(key_val));
cl_assert_equal_p(get_test_entry(map, "notInMap", ignore_case), NULL);
}

static void t_remove(struct hashmap *map, unsigned int ignore_case)
@ -211,24 +189,25 @@ static void t_remove(struct hashmap *map, unsigned int ignore_case)

for (size_t i = 0; i < ARRAY_SIZE(key_val); i++) {
entry = alloc_test_entry(key_val[i][0], key_val[i][1], ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);
}

for (size_t i = 0; i < ARRAY_SIZE(remove); i++) {
entry = alloc_test_entry(remove[i][0], "", ignore_case);
removed = hashmap_remove_entry(map, entry, ent, remove[i][0]);
if (check(removed != NULL))
check_str(get_value(removed), remove[i][1]);
cl_assert(removed != NULL);
cl_assert_equal_s(get_value(removed), remove[i][1]);
free(entry);
free(removed);
}

entry = alloc_test_entry("notInMap", "", ignore_case);
check_pointer_eq(hashmap_remove_entry(map, entry, ent, "notInMap"), NULL);
cl_assert_equal_p(hashmap_remove_entry(map, entry, ent, "notInMap"), NULL);
free(entry);

check_int(map->tablesize, ==, 64);
check_int(hashmap_get_size(map), ==, ARRAY_SIZE(key_val) - ARRAY_SIZE(remove));
cl_assert_equal_i(map->tablesize, 64);
cl_assert_equal_i(hashmap_get_size(map),
ARRAY_SIZE(key_val) - ARRAY_SIZE(remove));
}

static void t_iterate(struct hashmap *map, unsigned int ignore_case)
@ -242,38 +221,21 @@ static void t_iterate(struct hashmap *map, unsigned int ignore_case)

for (size_t i = 0; i < ARRAY_SIZE(key_val); i++) {
entry = alloc_test_entry(key_val[i][0], key_val[i][1], ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);
}

hashmap_for_each_entry(map, &iter, entry, ent /* member name */)
{
int ret;
if (!check_int((ret = key_val_contains(key_val, seen,
ARRAY_SIZE(key_val),
entry)), ==, 0)) {
switch (ret) {
case 1:
test_msg("found entry was not given in the input\n"
" key: %s\n value: %s",
entry->key, get_value(entry));
break;
case 2:
test_msg("duplicate entry detected\n"
" key: %s\n value: %s",
entry->key, get_value(entry));
break;
}
}
int ret = key_val_contains(key_val, seen,
ARRAY_SIZE(key_val),
entry);
cl_assert(ret == 0);
}

for (size_t i = 0; i < ARRAY_SIZE(seen); i++) {
if (!check_int(seen[i], ==, 1))
test_msg("following key-val pair was not iterated over:\n"
" key: %s\n value: %s",
key_val[i][0], key_val[i][1]);
}
for (size_t i = 0; i < ARRAY_SIZE(seen); i++)
cl_assert_equal_i(seen[i], 1);

check_int(hashmap_get_size(map), ==, ARRAY_SIZE(key_val));
cl_assert_equal_i(hashmap_get_size(map), ARRAY_SIZE(key_val));
}

static void t_alloc(struct hashmap *map, unsigned int ignore_case)
@ -284,17 +246,17 @@ static void t_alloc(struct hashmap *map, unsigned int ignore_case)
char *key = xstrfmt("key%d", i);
char *value = xstrfmt("value%d", i);
entry = alloc_test_entry(key, value, ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);
free(key);
free(value);
}
check_int(map->tablesize, ==, 64);
check_int(hashmap_get_size(map), ==, 51);
cl_assert_equal_i(map->tablesize, 64);
cl_assert_equal_i(hashmap_get_size(map), 51);

entry = alloc_test_entry("key52", "value52", ignore_case);
check_pointer_eq(hashmap_put_entry(map, entry, ent), NULL);
check_int(map->tablesize, ==, 256);
check_int(hashmap_get_size(map), ==, 52);
cl_assert_equal_p(hashmap_put_entry(map, entry, ent), NULL);
cl_assert_equal_i(map->tablesize, 256);
cl_assert_equal_i(hashmap_get_size(map), 52);

for (int i = 1; i <= 12; i++) {
char *key = xstrfmt("key%d", i);
@ -302,27 +264,27 @@ static void t_alloc(struct hashmap *map, unsigned int ignore_case)

entry = alloc_test_entry(key, "", ignore_case);
removed = hashmap_remove_entry(map, entry, ent, key);
if (check(removed != NULL))
check_str(value, get_value(removed));
cl_assert(removed != NULL);
cl_assert_equal_s(value, get_value(removed));
free(key);
free(value);
free(entry);
free(removed);
}
check_int(map->tablesize, ==, 256);
check_int(hashmap_get_size(map), ==, 40);
cl_assert_equal_i(map->tablesize, 256);
cl_assert_equal_i(hashmap_get_size(map), 40);

entry = alloc_test_entry("key40", "", ignore_case);
removed = hashmap_remove_entry(map, entry, ent, "key40");
if (check(removed != NULL))
check_str("value40", get_value(removed));
check_int(map->tablesize, ==, 64);
check_int(hashmap_get_size(map), ==, 39);
cl_assert(removed != NULL);
cl_assert_equal_s("value40", get_value(removed));
cl_assert_equal_i(map->tablesize, 64);
cl_assert_equal_i(hashmap_get_size(map), 39);
free(entry);
free(removed);
}

static void t_intern(void)
void test_hashmap__intern(void)
{
const char *values[] = { "value1", "Value1", "value2", "value2" };

@ -330,32 +292,68 @@ static void t_intern(void)
const char *i1 = strintern(values[i]);
const char *i2 = strintern(values[i]);

if (!check(!strcmp(i1, values[i])))
test_msg("strintern(%s) returns %s\n", values[i], i1);
else if (!check(i1 != values[i]))
test_msg("strintern(%s) returns input pointer\n",
values[i]);
else if (!check_pointer_eq(i1, i2))
test_msg("address('%s') != address('%s'), so strintern('%s') != strintern('%s')",
i1, i2, values[i], values[i]);
else
check_str(i1, values[i]);
cl_assert_equal_s(i1, values[i]);
cl_assert(i1 != values[i]);
cl_assert_equal_p(i1, i2);
}
}

int cmd_main(int argc UNUSED, const char **argv UNUSED)
void test_hashmap__replace_case_sensitive(void)
{
TEST(setup(t_replace, 0), "replace works");
TEST(setup(t_replace, 1), "replace (case insensitive) works");
TEST(setup(t_get, 0), "get works");
TEST(setup(t_get, 1), "get (case insensitive) works");
TEST(setup(t_add, 0), "add works");
TEST(setup(t_add, 1), "add (case insensitive) works");
TEST(setup(t_remove, 0), "remove works");
TEST(setup(t_remove, 1), "remove (case insensitive) works");
TEST(setup(t_iterate, 0), "iterate works");
TEST(setup(t_iterate, 1), "iterate (case insensitive) works");
TEST(setup(t_alloc, 0), "grow / shrink works");
TEST(t_intern(), "string interning works");
return test_done();
setup(t_replace, 0);
}

void test_hashmap__replace_case_insensitive(void)
{
setup(t_replace, 1);
}

void test_hashmap__get_case_sensitive(void)
{
setup(t_get, 0);
}

void test_hashmap__get_case_insensitive(void)
{
setup(t_get, 1);
}

void test_hashmap__add_case_sensitive(void)
{
setup(t_add, 0);
}

void test_hashmap__add_case_insensitive(void)
{
setup(t_add, 1);
}

void test_hashmap__remove_case_sensitive(void)
{
setup(t_remove, 0);
}

void test_hashmap__remove_case_insensitive(void)
{
setup(t_remove, 1);
}

void test_hashmap__iterate_case_sensitive(void)
{
setup(t_iterate, 0);
}

void test_hashmap__iterate_case_insensitive(void)
{
setup(t_iterate, 1);
}

void test_hashmap__alloc_case_sensitive(void)
{
setup(t_alloc, 0);
}

void test_hashmap__alloc_case_insensitive(void)
{
setup(t_alloc, 1);
}

119
t/unit-tests/u-strbuf.c Normal file
View File

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

/* wrapper that supplies tests with an empty, initialized strbuf */
static void setup(void (*f)(struct strbuf*, const void*),
const void *data)
{
struct strbuf buf = STRBUF_INIT;

f(&buf, data);
strbuf_release(&buf);
cl_assert_equal_i(buf.len, 0);
cl_assert_equal_i(buf.alloc, 0);
}

/* wrapper that supplies tests with a populated, initialized strbuf */
static void setup_populated(void (*f)(struct strbuf*, const void*),
const char *init_str, const void *data)
{
struct strbuf buf = STRBUF_INIT;

strbuf_addstr(&buf, init_str);
cl_assert_equal_i(buf.len, strlen(init_str));
f(&buf, data);
strbuf_release(&buf);
cl_assert_equal_i(buf.len, 0);
cl_assert_equal_i(buf.alloc, 0);
}

static void assert_sane_strbuf(struct strbuf *buf)
{
/* Initialized strbufs should always have a non-NULL buffer */
cl_assert(buf->buf != NULL);
/* Buffers should always be NUL-terminated */
cl_assert(buf->buf[buf->len] == '\0');
/*
* In case the buffer contains anything, `alloc` must alloc must
* be at least one byte larger than `len`.
*/
if (buf->len)
cl_assert(buf->len < buf->alloc);
}

void test_strbuf__static_init(void)
{
struct strbuf buf = STRBUF_INIT;

cl_assert_equal_i(buf.len, 0);
cl_assert_equal_i(buf.alloc, 0);
cl_assert(buf.buf[0] == '\0');
}

void test_strbuf__dynamic_init(void)
{
struct strbuf buf;

strbuf_init(&buf, 1024);
assert_sane_strbuf(&buf);
cl_assert_equal_i(buf.len, 0);
cl_assert(buf.alloc >= 1024);
cl_assert(buf.buf[0] == '\0');
strbuf_release(&buf);
}

static void t_addch(struct strbuf *buf, const void *data)
{
const char *p_ch = data;
const char ch = *p_ch;
size_t orig_alloc = buf->alloc;
size_t orig_len = buf->len;

assert_sane_strbuf(buf);
strbuf_addch(buf, ch);
assert_sane_strbuf(buf);
cl_assert_equal_i(buf->len, orig_len + 1);
cl_assert(buf->alloc >= orig_alloc);
cl_assert(buf->buf[buf->len] == '\0');
}

static void t_addstr(struct strbuf *buf, const void *data)
{
const char *text = data;
size_t len = strlen(text);
size_t orig_alloc = buf->alloc;
size_t orig_len = buf->len;

assert_sane_strbuf(buf);
strbuf_addstr(buf, text);
assert_sane_strbuf(buf);
cl_assert_equal_i(buf->len, orig_len + len);
cl_assert(buf->alloc >= orig_alloc);
cl_assert(buf->buf[buf->len] == '\0');
cl_assert_equal_s(buf->buf + orig_len, text);
}

void test_strbuf__add_single_char(void)
{
setup(t_addch, "a");
}

void test_strbuf__add_empty_char(void)
{
setup(t_addch, "");
}

void test_strbuf__add_append_char(void)
{
setup_populated(t_addch, "initial value", "a");
}

void test_strbuf__add_single_str(void)
{
setup(t_addstr, "hello there");
}

void test_strbuf__add_append_str(void)
{
setup_populated(t_addstr, "initial value", "hello there");
}

45
t/unit-tests/u-strcmp-offset.c Normal file
View File

@ -0,0 +1,45 @@
#include "unit-test.h"
#include "read-cache-ll.h"

static void check_strcmp_offset(const char *string1, const char *string2,
int expect_result, uintmax_t expect_offset)
{
size_t offset;
int result = strcmp_offset(string1, string2, &offset);

/*
* Because different CRTs behave differently, only rely on signs of the
* result values.
*/
result = (result < 0 ? -1 :
result > 0 ? 1 :
0);

cl_assert_equal_i(result, expect_result);
cl_assert_equal_i((uintmax_t)offset, expect_offset);
}

void test_strcmp_offset__empty(void)
{
check_strcmp_offset("", "", 0, 0);
}

void test_strcmp_offset__equal(void)
{
check_strcmp_offset("abc", "abc", 0, 3);
}

void test_strcmp_offset__different(void)
{
check_strcmp_offset("abc", "def", -1, 0);
}

void test_strcmp_offset__mismatch(void)
{
check_strcmp_offset("abc", "abz", -1, 2);
}

void test_strcmp_offset__different_length(void)
{
check_strcmp_offset("abc", "abcdef", -1, 3);
}