From 23eeee08d6a22de197b17e791508ddcb3a953dc7 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Fri, 13 Dec 2024 11:41:17 +0100 Subject: Makefile: drop -DSUPPRESS_ANNOTATED_LEAKS The -DSUPPRESS_ANNOTATED_LEAKS preprocessor directive was used to enable our `UNLEAK()` macro in the past, which marks memory as still-reachable so that the leak sanitizer does not complain. Starting with 52c7dbd036 (git-compat-util: drop now-unused `UNLEAK()` macro, 2024-11-20) this macro has been removed, and thus the preprocessor directive is not required anymore, either. Drop it. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- Makefile | 1 - 1 file changed, 1 deletion(-) (limited to 'Makefile') diff --git a/Makefile b/Makefile index 06f01149ec..2506f3b7e3 100644 --- a/Makefile +++ b/Makefile @@ -1490,7 +1490,6 @@ ifneq ($(filter undefined,$(SANITIZERS)),) BASIC_CFLAGS += -DSHA1DC_FORCE_ALIGNED_ACCESS endif ifneq ($(filter leak,$(SANITIZERS)),) -BASIC_CFLAGS += -DSUPPRESS_ANNOTATED_LEAKS BASIC_CFLAGS += -O0 SANITIZE_LEAK = YesCompiledWithIt endif -- cgit v1.2.3 From c081e7340f5545342f80e77f4578851d77dc9cf6 Mon Sep 17 00:00:00 2001 From: Patrick Steinhardt Date: Fri, 13 Dec 2024 11:41:18 +0100 Subject: t/unit-tests: rename clar-based unit tests to have a common prefix All of the code files for unit tests using the self-grown unit testing framework have a "t-" prefix to their name. This makes it easy to identify them and use globbing in our Makefile and in other places. On the other hand though, our clar-based unit tests have no prefix at all and thus cannot easily be discerned from other files in the unit test directory. Introduce a new "u-" prefix for clar-based unit tests. This prefix will be used in a subsequent commit to easily identify such tests. Signed-off-by: Patrick Steinhardt Signed-off-by: Junio C Hamano --- Makefile | 4 +- t/meson.build | 4 +- t/unit-tests/ctype.c | 102 ------------ t/unit-tests/generate-clar-decls.sh | 5 +- t/unit-tests/strvec.c | 306 ------------------------------------ t/unit-tests/u-ctype.c | 102 ++++++++++++ t/unit-tests/u-strvec.c | 306 ++++++++++++++++++++++++++++++++++++ 7 files changed, 416 insertions(+), 413 deletions(-) delete mode 100644 t/unit-tests/ctype.c delete mode 100644 t/unit-tests/strvec.c create mode 100644 t/unit-tests/u-ctype.c create mode 100644 t/unit-tests/u-strvec.c (limited to 'Makefile') diff --git a/Makefile b/Makefile index 2506f3b7e3..6eafaf174a 100644 --- a/Makefile +++ b/Makefile @@ -1344,8 +1344,8 @@ THIRD_PARTY_SOURCES += sha1dc/% THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/% THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/clar/% -CLAR_TEST_SUITES += ctype -CLAR_TEST_SUITES += strvec +CLAR_TEST_SUITES += u-ctype +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 diff --git a/t/meson.build b/t/meson.build index 13fe854ba0..9e676e6936 100644 --- a/t/meson.build +++ b/t/meson.build @@ -1,6 +1,6 @@ clar_test_suites = [ - 'unit-tests/ctype.c', - 'unit-tests/strvec.c', + 'unit-tests/u-ctype.c', + 'unit-tests/u-strvec.c', ] clar_sources = [ diff --git a/t/unit-tests/ctype.c b/t/unit-tests/ctype.c deleted file mode 100644 index 32e65867cd..0000000000 --- a/t/unit-tests/ctype.c +++ /dev/null @@ -1,102 +0,0 @@ -#include "unit-test.h" - -#define TEST_CHAR_CLASS(class, string) do { \ - size_t len = ARRAY_SIZE(string) - 1 + \ - BUILD_ASSERT_OR_ZERO(ARRAY_SIZE(string) > 0) + \ - BUILD_ASSERT_OR_ZERO(sizeof(string[0]) == sizeof(char)); \ - for (int i = 0; i < 256; i++) { \ - int actual = class(i), expect = !!memchr(string, i, len); \ - if (actual != expect) \ - cl_failf("0x%02x is classified incorrectly: expected %d, got %d", \ - i, expect, actual); \ - } \ - cl_assert(!class(EOF)); \ -} while (0) - -#define DIGIT "0123456789" -#define LOWER "abcdefghijklmnopqrstuvwxyz" -#define UPPER "ABCDEFGHIJKLMNOPQRSTUVWXYZ" -#define PUNCT "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" -#define ASCII \ - "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" \ - "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" \ - "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f" \ - "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f" \ - "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f" \ - "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f" \ - "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f" \ - "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f" -#define CNTRL \ - "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" \ - "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" \ - "\x7f" - -void test_ctype__isspace(void) -{ - TEST_CHAR_CLASS(isspace, " \n\r\t"); -} - -void test_ctype__isdigit(void) -{ - TEST_CHAR_CLASS(isdigit, DIGIT); -} - -void test_ctype__isalpha(void) -{ - TEST_CHAR_CLASS(isalpha, LOWER UPPER); -} - -void test_ctype__isalnum(void) -{ - TEST_CHAR_CLASS(isalnum, LOWER UPPER DIGIT); -} - -void test_ctype__is_glob_special(void) -{ - TEST_CHAR_CLASS(is_glob_special, "*?[\\"); -} - -void test_ctype__is_regex_special(void) -{ - TEST_CHAR_CLASS(is_regex_special, "$()*+.?[\\^{|"); -} - -void test_ctype__is_pathspec_magic(void) -{ - TEST_CHAR_CLASS(is_pathspec_magic, "!\"#%&',-/:;<=>@_`~"); -} - -void test_ctype__isascii(void) -{ - TEST_CHAR_CLASS(isascii, ASCII); -} - -void test_ctype__islower(void) -{ - TEST_CHAR_CLASS(islower, LOWER); -} - -void test_ctype__isupper(void) -{ - TEST_CHAR_CLASS(isupper, UPPER); -} - -void test_ctype__iscntrl(void) -{ - TEST_CHAR_CLASS(iscntrl, CNTRL); -} - -void test_ctype__ispunct(void) -{ - TEST_CHAR_CLASS(ispunct, PUNCT); -} - -void test_ctype__isxdigit(void) -{ - TEST_CHAR_CLASS(isxdigit, DIGIT "abcdefABCDEF"); -} - -void test_ctype__isprint(void) -{ - TEST_CHAR_CLASS(isprint, LOWER UPPER DIGIT PUNCT " "); -} diff --git a/t/unit-tests/generate-clar-decls.sh b/t/unit-tests/generate-clar-decls.sh index 688e0885f4..3b315c64b3 100755 --- a/t/unit-tests/generate-clar-decls.sh +++ b/t/unit-tests/generate-clar-decls.sh @@ -11,6 +11,9 @@ shift for suite in "$@" do - sed -ne "s/^\(void test_$(basename "${suite%.c}")__[a-zA-Z_0-9][a-zA-Z_0-9]*(void)\)$/extern \1;/p" "$suite" || + suite_name=$(basename "$suite") + suite_name=${suite_name%.c} + suite_name=${suite_name#u-} + sed -ne "s/^\(void test_${suite_name}__[a-zA-Z_0-9][a-zA-Z_0-9]*(void)\)$/extern \1;/p" "$suite" || exit 1 done >"$OUTPUT" diff --git a/t/unit-tests/strvec.c b/t/unit-tests/strvec.c deleted file mode 100644 index 855b602337..0000000000 --- a/t/unit-tests/strvec.c +++ /dev/null @@ -1,306 +0,0 @@ -#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__splice_with_same_size_replacement(void) -{ - struct strvec vec = STRVEC_INIT; - const char *replacement[] = { "1" }; - - strvec_pushl(&vec, "foo", "bar", "baz", NULL); - strvec_splice(&vec, 1, 1, replacement, ARRAY_SIZE(replacement)); - check_strvec(&vec, "foo", "1", "baz", NULL); - strvec_clear(&vec); -} - -void test_strvec__splice_with_smaller_replacement(void) -{ - struct strvec vec = STRVEC_INIT; - const char *replacement[] = { "1" }; - - strvec_pushl(&vec, "foo", "bar", "baz", NULL); - strvec_splice(&vec, 1, 2, replacement, ARRAY_SIZE(replacement)); - check_strvec(&vec, "foo", "1", NULL); - strvec_clear(&vec); -} - -void test_strvec__splice_with_bigger_replacement(void) -{ - struct strvec vec = STRVEC_INIT; - const char *replacement[] = { "1", "2", "3" }; - - strvec_pushl(&vec, "foo", "bar", "baz", NULL); - strvec_splice(&vec, 0, 2, replacement, ARRAY_SIZE(replacement)); - check_strvec(&vec, "1", "2", "3", "baz", NULL); - strvec_clear(&vec); -} - -void test_strvec__splice_with_empty_replacement(void) -{ - struct strvec vec = STRVEC_INIT; - - strvec_pushl(&vec, "foo", "bar", "baz", NULL); - strvec_splice(&vec, 0, 2, NULL, 0); - check_strvec(&vec, "baz", NULL); - strvec_clear(&vec); -} - -void test_strvec__splice_with_empty_original(void) -{ - struct strvec vec = STRVEC_INIT; - const char *replacement[] = { "1", "2" }; - - strvec_pushl(&vec, "foo", "bar", "baz", NULL); - strvec_splice(&vec, 1, 0, replacement, ARRAY_SIZE(replacement)); - check_strvec(&vec, "foo", "1", "2", "bar", "baz", NULL); - strvec_clear(&vec); -} - -void test_strvec__splice_at_tail(void) -{ - struct strvec vec = STRVEC_INIT; - const char *replacement[] = { "1", "2" }; - - strvec_pushl(&vec, "foo", "bar", NULL); - strvec_splice(&vec, 2, 0, replacement, ARRAY_SIZE(replacement)); - check_strvec(&vec, "foo", "bar", "1", "2", 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); -} diff --git a/t/unit-tests/u-ctype.c b/t/unit-tests/u-ctype.c new file mode 100644 index 0000000000..32e65867cd --- /dev/null +++ b/t/unit-tests/u-ctype.c @@ -0,0 +1,102 @@ +#include "unit-test.h" + +#define TEST_CHAR_CLASS(class, string) do { \ + size_t len = ARRAY_SIZE(string) - 1 + \ + BUILD_ASSERT_OR_ZERO(ARRAY_SIZE(string) > 0) + \ + BUILD_ASSERT_OR_ZERO(sizeof(string[0]) == sizeof(char)); \ + for (int i = 0; i < 256; i++) { \ + int actual = class(i), expect = !!memchr(string, i, len); \ + if (actual != expect) \ + cl_failf("0x%02x is classified incorrectly: expected %d, got %d", \ + i, expect, actual); \ + } \ + cl_assert(!class(EOF)); \ +} while (0) + +#define DIGIT "0123456789" +#define LOWER "abcdefghijklmnopqrstuvwxyz" +#define UPPER "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +#define PUNCT "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" +#define ASCII \ + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" \ + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" \ + "\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f" \ + "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f" \ + "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f" \ + "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f" \ + "\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f" \ + "\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f" +#define CNTRL \ + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" \ + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" \ + "\x7f" + +void test_ctype__isspace(void) +{ + TEST_CHAR_CLASS(isspace, " \n\r\t"); +} + +void test_ctype__isdigit(void) +{ + TEST_CHAR_CLASS(isdigit, DIGIT); +} + +void test_ctype__isalpha(void) +{ + TEST_CHAR_CLASS(isalpha, LOWER UPPER); +} + +void test_ctype__isalnum(void) +{ + TEST_CHAR_CLASS(isalnum, LOWER UPPER DIGIT); +} + +void test_ctype__is_glob_special(void) +{ + TEST_CHAR_CLASS(is_glob_special, "*?[\\"); +} + +void test_ctype__is_regex_special(void) +{ + TEST_CHAR_CLASS(is_regex_special, "$()*+.?[\\^{|"); +} + +void test_ctype__is_pathspec_magic(void) +{ + TEST_CHAR_CLASS(is_pathspec_magic, "!\"#%&',-/:;<=>@_`~"); +} + +void test_ctype__isascii(void) +{ + TEST_CHAR_CLASS(isascii, ASCII); +} + +void test_ctype__islower(void) +{ + TEST_CHAR_CLASS(islower, LOWER); +} + +void test_ctype__isupper(void) +{ + TEST_CHAR_CLASS(isupper, UPPER); +} + +void test_ctype__iscntrl(void) +{ + TEST_CHAR_CLASS(iscntrl, CNTRL); +} + +void test_ctype__ispunct(void) +{ + TEST_CHAR_CLASS(ispunct, PUNCT); +} + +void test_ctype__isxdigit(void) +{ + TEST_CHAR_CLASS(isxdigit, DIGIT "abcdefABCDEF"); +} + +void test_ctype__isprint(void) +{ + TEST_CHAR_CLASS(isprint, LOWER UPPER DIGIT PUNCT " "); +} diff --git a/t/unit-tests/u-strvec.c b/t/unit-tests/u-strvec.c new file mode 100644 index 0000000000..855b602337 --- /dev/null +++ b/t/unit-tests/u-strvec.c @@ -0,0 +1,306 @@ +#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__splice_with_same_size_replacement(void) +{ + struct strvec vec = STRVEC_INIT; + const char *replacement[] = { "1" }; + + strvec_pushl(&vec, "foo", "bar", "baz", NULL); + strvec_splice(&vec, 1, 1, replacement, ARRAY_SIZE(replacement)); + check_strvec(&vec, "foo", "1", "baz", NULL); + strvec_clear(&vec); +} + +void test_strvec__splice_with_smaller_replacement(void) +{ + struct strvec vec = STRVEC_INIT; + const char *replacement[] = { "1" }; + + strvec_pushl(&vec, "foo", "bar", "baz", NULL); + strvec_splice(&vec, 1, 2, replacement, ARRAY_SIZE(replacement)); + check_strvec(&vec, "foo", "1", NULL); + strvec_clear(&vec); +} + +void test_strvec__splice_with_bigger_replacement(void) +{ + struct strvec vec = STRVEC_INIT; + const char *replacement[] = { "1", "2", "3" }; + + strvec_pushl(&vec, "foo", "bar", "baz", NULL); + strvec_splice(&vec, 0, 2, replacement, ARRAY_SIZE(replacement)); + check_strvec(&vec, "1", "2", "3", "baz", NULL); + strvec_clear(&vec); +} + +void test_strvec__splice_with_empty_replacement(void) +{ + struct strvec vec = STRVEC_INIT; + + strvec_pushl(&vec, "foo", "bar", "baz", NULL); + strvec_splice(&vec, 0, 2, NULL, 0); + check_strvec(&vec, "baz", NULL); + strvec_clear(&vec); +} + +void test_strvec__splice_with_empty_original(void) +{ + struct strvec vec = STRVEC_INIT; + const char *replacement[] = { "1", "2" }; + + strvec_pushl(&vec, "foo", "bar", "baz", NULL); + strvec_splice(&vec, 1, 0, replacement, ARRAY_SIZE(replacement)); + check_strvec(&vec, "foo", "1", "2", "bar", "baz", NULL); + strvec_clear(&vec); +} + +void test_strvec__splice_at_tail(void) +{ + struct strvec vec = STRVEC_INIT; + const char *replacement[] = { "1", "2" }; + + strvec_pushl(&vec, "foo", "bar", NULL); + strvec_splice(&vec, 2, 0, replacement, ARRAY_SIZE(replacement)); + check_strvec(&vec, "foo", "bar", "1", "2", 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); +} -- cgit v1.2.3