+5

.clang-format

··· 196 196 - 'strmap_for_each_entry' 197 197 - 'strset_for_each_entry' 198 198 199 199 + # A list of macros that should be interpreted as conditionals instead of as 200 200 + # function calls. 201 201 + IfMacros: 202 202 + - 'if_test' 203 203 + 199 204 # The maximum number of consecutive empty lines to keep. 200 205 MaxEmptyLinesToKeep: 1 201 206

+35

t/helper/test-example-tap.c

··· 72 72 73 73 int cmd__example_tap(int argc, const char **argv) 74 74 { 75 75 + check(1); 76 76 + 75 77 test_res = TEST(check_res = check_int(1, ==, 1), "passing test"); 76 78 TEST(t_res(1), "passing test and assertion return 1"); 77 79 test_res = TEST(check_res = check_int(1, ==, 2), "failing test"); ··· 91 93 TEST(t_messages(), "messages from failing string and char comparison"); 92 94 test_res = TEST(t_empty(), "test with no checks"); 93 95 TEST(check_int(test_res, ==, 0), "test with no checks returns 0"); 96 96 + 97 97 + if_test ("if_test passing test") 98 98 + check_int(1, ==, 1); 99 99 + if_test ("if_test failing test") 100 100 + check_int(1, ==, 2); 101 101 + if_test ("if_test passing TEST_TODO()") 102 102 + TEST_TODO(check(0)); 103 103 + if_test ("if_test failing TEST_TODO()") 104 104 + TEST_TODO(check(1)); 105 105 + if_test ("if_test test_skip()") { 106 106 + check(0); 107 107 + test_skip("missing prerequisite"); 108 108 + check(1); 109 109 + } 110 110 + if_test ("if_test test_skip() inside TEST_TODO()") 111 111 + TEST_TODO((test_skip("missing prerequisite"), 1)); 112 112 + if_test ("if_test TEST_TODO() after failing check") { 113 113 + check(0); 114 114 + TEST_TODO(check(0)); 115 115 + } 116 116 + if_test ("if_test failing check after TEST_TODO()") { 117 117 + check(1); 118 118 + TEST_TODO(check(0)); 119 119 + check(0); 120 120 + } 121 121 + if_test ("if_test messages from failing string and char comparison") { 122 122 + check_str("\thello\\", "there\"\n"); 123 123 + check_str("NULL", NULL); 124 124 + check_char('a', ==, '\n'); 125 125 + check_char('\\', ==, '\''); 126 126 + } 127 127 + if_test ("if_test test with no checks") 128 128 + ; /* nothing */ 94 129 95 130 return test_done(); 96 131 }

+47 -13

t/t0080-unit-test-output.sh

··· 5 5 TEST_PASSES_SANITIZE_LEAK=true 6 6 . ./test-lib.sh 7 7 8 8 - test_expect_success 'TAP output from unit tests' ' 8 8 + test_expect_success 'TAP output from unit tests' - <<\EOT 9 9 cat >expect <<-EOF && 10 10 + # BUG: check outside of test at t/helper/test-example-tap.c:75 10 11 ok 1 - passing test 11 12 ok 2 - passing test and assertion return 1 12 12 - # check "1 == 2" failed at t/helper/test-example-tap.c:77 13 13 + # check "1 == 2" failed at t/helper/test-example-tap.c:79 13 14 # left: 1 14 15 # right: 2 15 16 not ok 3 - failing test 16 17 ok 4 - failing test and assertion return 0 17 18 not ok 5 - passing TEST_TODO() # TODO 18 19 ok 6 - passing TEST_TODO() returns 1 19 19 - # todo check ${SQ}check(x)${SQ} succeeded at t/helper/test-example-tap.c:26 20 20 + # todo check 'check(x)' succeeded at t/helper/test-example-tap.c:26 20 21 not ok 7 - failing TEST_TODO() 21 22 ok 8 - failing TEST_TODO() returns 0 22 23 # check "0" failed at t/helper/test-example-tap.c:31 23 24 # skipping test - missing prerequisite 24 24 - # skipping check ${SQ}1${SQ} at t/helper/test-example-tap.c:33 25 25 + # skipping check '1' at t/helper/test-example-tap.c:33 25 26 ok 9 - test_skip() # SKIP 26 27 ok 10 - skipped test returns 1 27 28 # skipping test - missing prerequisite ··· 39 40 # check "!strcmp("NULL", NULL)" failed at t/helper/test-example-tap.c:63 40 41 # left: "NULL" 41 42 # right: NULL 42 42 - # check "${SQ}a${SQ} == ${SQ}\n${SQ}" failed at t/helper/test-example-tap.c:64 43 43 - # left: ${SQ}a${SQ} 44 44 - # right: ${SQ}\012${SQ} 45 45 - # check "${SQ}\\\\${SQ} == ${SQ}\\${SQ}${SQ}" failed at t/helper/test-example-tap.c:65 46 46 - # left: ${SQ}\\\\${SQ} 47 47 - # right: ${SQ}\\${SQ}${SQ} 43 43 + # check "'a' == '\n'" failed at t/helper/test-example-tap.c:64 44 44 + # left: 'a' 45 45 + # right: '\012' 46 46 + # check "'\\\\' == '\\''" failed at t/helper/test-example-tap.c:65 47 47 + # left: '\\\\' 48 48 + # right: '\\'' 48 49 not ok 17 - messages from failing string and char comparison 49 49 - # BUG: test has no checks at t/helper/test-example-tap.c:92 50 50 + # BUG: test has no checks at t/helper/test-example-tap.c:94 50 51 not ok 18 - test with no checks 51 52 ok 19 - test with no checks returns 0 52 52 - 1..19 53 53 + ok 20 - if_test passing test 54 54 + # check "1 == 2" failed at t/helper/test-example-tap.c:100 55 55 + # left: 1 56 56 + # right: 2 57 57 + not ok 21 - if_test failing test 58 58 + not ok 22 - if_test passing TEST_TODO() # TODO 59 59 + # todo check 'check(1)' succeeded at t/helper/test-example-tap.c:104 60 60 + not ok 23 - if_test failing TEST_TODO() 61 61 + # check "0" failed at t/helper/test-example-tap.c:106 62 62 + # skipping test - missing prerequisite 63 63 + # skipping check '1' at t/helper/test-example-tap.c:108 64 64 + ok 24 - if_test test_skip() # SKIP 65 65 + # skipping test - missing prerequisite 66 66 + ok 25 - if_test test_skip() inside TEST_TODO() # SKIP 67 67 + # check "0" failed at t/helper/test-example-tap.c:113 68 68 + not ok 26 - if_test TEST_TODO() after failing check 69 69 + # check "0" failed at t/helper/test-example-tap.c:119 70 70 + not ok 27 - if_test failing check after TEST_TODO() 71 71 + # check "!strcmp("\thello\\\\", "there\"\n")" failed at t/helper/test-example-tap.c:122 72 72 + # left: "\011hello\\\\" 73 73 + # right: "there\"\012" 74 74 + # check "!strcmp("NULL", NULL)" failed at t/helper/test-example-tap.c:123 75 75 + # left: "NULL" 76 76 + # right: NULL 77 77 + # check "'a' == '\n'" failed at t/helper/test-example-tap.c:124 78 78 + # left: 'a' 79 79 + # right: '\012' 80 80 + # check "'\\\\' == '\\''" failed at t/helper/test-example-tap.c:125 81 81 + # left: '\\\\' 82 82 + # right: '\\'' 83 83 + not ok 28 - if_test messages from failing string and char comparison 84 84 + # BUG: test has no checks at t/helper/test-example-tap.c:127 85 85 + not ok 29 - if_test test with no checks 86 86 + 1..29 53 87 EOF 54 88 55 89 ! test-tool example-tap >actual && 56 90 test_cmp expect actual 57 57 - ' 91 91 + EOT 58 92 59 93 test_done

+1 -3

t/unit-tests/t-ctype.c

··· 4 4 size_t len = ARRAY_SIZE(string) - 1 + \ 5 5 BUILD_ASSERT_OR_ZERO(ARRAY_SIZE(string) > 0) + \ 6 6 BUILD_ASSERT_OR_ZERO(sizeof(string[0]) == sizeof(char)); \ 7 7 - int skip = test__run_begin(); \ 8 8 - if (!skip) { \ 7 7 + if_test (#class " works") { \ 9 8 for (int i = 0; i < 256; i++) { \ 10 9 if (!check_int(class(i), ==, !!memchr(string, i, len)))\ 11 10 test_msg(" i: 0x%02x", i); \ 12 11 } \ 13 12 check(!class(EOF)); \ 14 13 } \ 15 15 - test__run_end(!skip, TEST_LOCATION(), #class " works"); \ 16 14 } while (0) 17 15 18 16 #define DIGIT "0123456789"

+104 -120

t/unit-tests/t-reftable-basics.c

··· 20 20 return args->needle <= args->haystack[i]; 21 21 } 22 22 23 23 - static void test_binsearch(void) 23 23 + int cmd_main(int argc, const char *argv[]) 24 24 { 25 25 - int haystack[] = { 2, 4, 6, 8, 10 }; 26 26 - struct { 27 27 - int needle; 28 28 - size_t expected_idx; 29 29 - } testcases[] = { 30 30 - {-9000, 0}, 31 31 - {-1, 0}, 32 32 - {0, 0}, 33 33 - {2, 0}, 34 34 - {3, 1}, 35 35 - {4, 1}, 36 36 - {7, 3}, 37 37 - {9, 4}, 38 38 - {10, 4}, 39 39 - {11, 5}, 40 40 - {9000, 5}, 41 41 - }; 42 42 - 43 43 - for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) { 44 44 - struct integer_needle_lesseq_args args = { 45 45 - .haystack = haystack, 46 46 - .needle = testcases[i].needle, 25 25 + if_test ("binary search with binsearch works") { 26 26 + int haystack[] = { 2, 4, 6, 8, 10 }; 27 27 + struct { 28 28 + int needle; 29 29 + size_t expected_idx; 30 30 + } testcases[] = { 31 31 + {-9000, 0}, 32 32 + {-1, 0}, 33 33 + {0, 0}, 34 34 + {2, 0}, 35 35 + {3, 1}, 36 36 + {4, 1}, 37 37 + {7, 3}, 38 38 + {9, 4}, 39 39 + {10, 4}, 40 40 + {11, 5}, 41 41 + {9000, 5}, 47 42 }; 48 48 - size_t idx; 49 43 50 50 - idx = binsearch(ARRAY_SIZE(haystack), &integer_needle_lesseq, &args); 51 51 - check_int(idx, ==, testcases[i].expected_idx); 44 44 + for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) { 45 45 + struct integer_needle_lesseq_args args = { 46 46 + .haystack = haystack, 47 47 + .needle = testcases[i].needle, 48 48 + }; 49 49 + size_t idx; 50 50 + 51 51 + idx = binsearch(ARRAY_SIZE(haystack), 52 52 + &integer_needle_lesseq, &args); 53 53 + check_int(idx, ==, testcases[i].expected_idx); 54 54 + } 52 55 } 53 53 - } 54 56 55 55 - static void test_names_length(void) 56 56 - { 57 57 - const char *a[] = { "a", "b", NULL }; 58 58 - check_int(names_length(a), ==, 2); 59 59 - } 57 57 + if_test ("names_length retuns size of a NULL-terminated string array") { 58 58 + const char *a[] = { "a", "b", NULL }; 59 59 + check_int(names_length(a), ==, 2); 60 60 + } 60 61 61 61 - static void test_names_equal(void) 62 62 - { 63 63 - const char *a[] = { "a", "b", "c", NULL }; 64 64 - const char *b[] = { "a", "b", "d", NULL }; 65 65 - const char *c[] = { "a", "b", NULL }; 62 62 + if_test ("names_equal compares NULL-terminated string arrays") { 63 63 + const char *a[] = { "a", "b", "c", NULL }; 64 64 + const char *b[] = { "a", "b", "d", NULL }; 65 65 + const char *c[] = { "a", "b", NULL }; 66 66 67 67 - check(names_equal(a, a)); 68 68 - check(!names_equal(a, b)); 69 69 - check(!names_equal(a, c)); 70 70 - } 67 67 + check(names_equal(a, a)); 68 68 + check(!names_equal(a, b)); 69 69 + check(!names_equal(a, c)); 70 70 + } 71 71 72 72 - static void test_parse_names_normal(void) 73 73 - { 74 74 - char in1[] = "line\n"; 75 75 - char in2[] = "a\nb\nc"; 76 76 - char **out = NULL; 77 77 - parse_names(in1, strlen(in1), &out); 78 78 - check_str(out[0], "line"); 79 79 - check(!out[1]); 80 80 - free_names(out); 72 72 + if_test ("parse_names works for basic input") { 73 73 + char in1[] = "line\n"; 74 74 + char in2[] = "a\nb\nc"; 75 75 + char **out = NULL; 76 76 + parse_names(in1, strlen(in1), &out); 77 77 + check_str(out[0], "line"); 78 78 + check(!out[1]); 79 79 + free_names(out); 81 80 82 82 - parse_names(in2, strlen(in2), &out); 83 83 - check_str(out[0], "a"); 84 84 - check_str(out[1], "b"); 85 85 - check_str(out[2], "c"); 86 86 - check(!out[3]); 87 87 - free_names(out); 88 88 - } 81 81 + parse_names(in2, strlen(in2), &out); 82 82 + check_str(out[0], "a"); 83 83 + check_str(out[1], "b"); 84 84 + check_str(out[2], "c"); 85 85 + check(!out[3]); 86 86 + free_names(out); 87 87 + } 89 88 90 90 - static void test_parse_names_drop_empty(void) 91 91 - { 92 92 - char in[] = "a\n\nb\n"; 93 93 - char **out = NULL; 94 94 - parse_names(in, strlen(in), &out); 95 95 - check_str(out[0], "a"); 96 96 - /* simply '\n' should be dropped as empty string */ 97 97 - check_str(out[1], "b"); 98 98 - check(!out[2]); 99 99 - free_names(out); 100 100 - } 89 89 + if_test ("parse_names drops empty string") { 90 90 + char in[] = "a\n\nb\n"; 91 91 + char **out = NULL; 92 92 + parse_names(in, strlen(in), &out); 93 93 + check_str(out[0], "a"); 94 94 + /* simply '\n' should be dropped as empty string */ 95 95 + check_str(out[1], "b"); 96 96 + check(!out[2]); 97 97 + free_names(out); 98 98 + } 101 99 102 102 - static void test_common_prefix(void) 103 103 - { 104 104 - struct strbuf a = STRBUF_INIT; 105 105 - struct strbuf b = STRBUF_INIT; 106 106 - struct { 107 107 - const char *a, *b; 108 108 - int want; 109 109 - } cases[] = { 110 110 - {"abcdef", "abc", 3}, 111 111 - { "abc", "ab", 2 }, 112 112 - { "", "abc", 0 }, 113 113 - { "abc", "abd", 2 }, 114 114 - { "abc", "pqr", 0 }, 115 115 - }; 100 100 + if_test ("common_prefix_size works") { 101 101 + struct strbuf a = STRBUF_INIT; 102 102 + struct strbuf b = STRBUF_INIT; 103 103 + struct { 104 104 + const char *a, *b; 105 105 + int want; 106 106 + } cases[] = { 107 107 + {"abcdef", "abc", 3}, 108 108 + { "abc", "ab", 2 }, 109 109 + { "", "abc", 0 }, 110 110 + { "abc", "abd", 2 }, 111 111 + { "abc", "pqr", 0 }, 112 112 + }; 116 113 117 117 - for (size_t i = 0; i < ARRAY_SIZE(cases); i++) { 118 118 - strbuf_addstr(&a, cases[i].a); 119 119 - strbuf_addstr(&b, cases[i].b); 120 120 - check_int(common_prefix_size(&a, &b), ==, cases[i].want); 121 121 - strbuf_reset(&a); 122 122 - strbuf_reset(&b); 114 114 + for (size_t i = 0; i < ARRAY_SIZE(cases); i++) { 115 115 + strbuf_addstr(&a, cases[i].a); 116 116 + strbuf_addstr(&b, cases[i].b); 117 117 + check_int(common_prefix_size(&a, &b), ==, cases[i].want); 118 118 + strbuf_reset(&a); 119 119 + strbuf_reset(&b); 120 120 + } 121 121 + strbuf_release(&a); 122 122 + strbuf_release(&b); 123 123 } 124 124 - strbuf_release(&a); 125 125 - strbuf_release(&b); 126 126 - } 127 124 128 128 - static void test_u24_roundtrip(void) 129 129 - { 130 130 - uint32_t in = 0x112233; 131 131 - uint8_t dest[3]; 132 132 - uint32_t out; 133 133 - put_be24(dest, in); 134 134 - out = get_be24(dest); 135 135 - check_int(in, ==, out); 136 136 - } 137 137 - 138 138 - static void test_u16_roundtrip(void) 139 139 - { 140 140 - uint32_t in = 0xfef1; 141 141 - uint8_t dest[3]; 142 142 - uint32_t out; 143 143 - put_be16(dest, in); 144 144 - out = get_be16(dest); 145 145 - check_int(in, ==, out); 146 146 - } 125 125 + if_test ("put_be24 and get_be24 work") { 126 126 + uint32_t in = 0x112233; 127 127 + uint8_t dest[3]; 128 128 + uint32_t out; 129 129 + put_be24(dest, in); 130 130 + out = get_be24(dest); 131 131 + check_int(in, ==, out); 132 132 + } 147 133 148 148 - int cmd_main(int argc, const char *argv[]) 149 149 - { 150 150 - TEST(test_common_prefix(), "common_prefix_size works"); 151 151 - TEST(test_parse_names_normal(), "parse_names works for basic input"); 152 152 - TEST(test_parse_names_drop_empty(), "parse_names drops empty string"); 153 153 - TEST(test_binsearch(), "binary search with binsearch works"); 154 154 - TEST(test_names_length(), "names_length retuns size of a NULL-terminated string array"); 155 155 - TEST(test_names_equal(), "names_equal compares NULL-terminated string arrays"); 156 156 - TEST(test_u24_roundtrip(), "put_be24 and get_be24 work"); 157 157 - TEST(test_u16_roundtrip(), "put_be16 and get_be16 work"); 134 134 + if_test ("put_be16 and get_be16 work") { 135 135 + uint32_t in = 0xfef1; 136 136 + uint8_t dest[3]; 137 137 + uint32_t out; 138 138 + put_be16(dest, in); 139 139 + out = get_be16(dest); 140 140 + check_int(in, ==, out); 141 141 + } 158 142 159 143 return test_done(); 160 144 }

+156 -200

t/unit-tests/t-strvec.c

··· 19 19 } \ 20 20 } while (0) 21 21 22 22 - static void t_static_init(void) 22 22 + int cmd_main(int argc, const char **argv) 23 23 { 24 24 - struct strvec vec = STRVEC_INIT; 25 25 - check_pointer_eq(vec.v, empty_strvec); 26 26 - check_uint(vec.nr, ==, 0); 27 27 - check_uint(vec.alloc, ==, 0); 28 28 - } 24 24 + if_test ("static initialization") { 25 25 + struct strvec vec = STRVEC_INIT; 26 26 + check_pointer_eq(vec.v, empty_strvec); 27 27 + check_uint(vec.nr, ==, 0); 28 28 + check_uint(vec.alloc, ==, 0); 29 29 + } 29 30 30 30 - static void t_dynamic_init(void) 31 31 - { 32 32 - struct strvec vec; 33 33 - strvec_init(&vec); 34 34 - check_pointer_eq(vec.v, empty_strvec); 35 35 - check_uint(vec.nr, ==, 0); 36 36 - check_uint(vec.alloc, ==, 0); 37 37 - } 31 31 + if_test ("dynamic initialization") { 32 32 + struct strvec vec; 33 33 + strvec_init(&vec); 34 34 + check_pointer_eq(vec.v, empty_strvec); 35 35 + check_uint(vec.nr, ==, 0); 36 36 + check_uint(vec.alloc, ==, 0); 37 37 + } 38 38 39 39 - static void t_clear(void) 40 40 - { 41 41 - struct strvec vec = STRVEC_INIT; 42 42 - strvec_push(&vec, "foo"); 43 43 - strvec_clear(&vec); 44 44 - check_pointer_eq(vec.v, empty_strvec); 45 45 - check_uint(vec.nr, ==, 0); 46 46 - check_uint(vec.alloc, ==, 0); 47 47 - } 39 39 + if_test ("clear") { 40 40 + struct strvec vec = STRVEC_INIT; 41 41 + strvec_push(&vec, "foo"); 42 42 + strvec_clear(&vec); 43 43 + check_pointer_eq(vec.v, empty_strvec); 44 44 + check_uint(vec.nr, ==, 0); 45 45 + check_uint(vec.alloc, ==, 0); 46 46 + } 48 47 49 49 - static void t_push(void) 50 50 - { 51 51 - struct strvec vec = STRVEC_INIT; 48 48 + if_test ("push") { 49 49 + struct strvec vec = STRVEC_INIT; 52 50 53 53 - strvec_push(&vec, "foo"); 54 54 - check_strvec(&vec, "foo", NULL); 51 51 + strvec_push(&vec, "foo"); 52 52 + check_strvec(&vec, "foo", NULL); 55 53 56 56 - strvec_push(&vec, "bar"); 57 57 - check_strvec(&vec, "foo", "bar", NULL); 54 54 + strvec_push(&vec, "bar"); 55 55 + check_strvec(&vec, "foo", "bar", NULL); 58 56 59 59 - strvec_clear(&vec); 60 60 - } 57 57 + strvec_clear(&vec); 58 58 + } 61 59 62 62 - static void t_pushf(void) 63 63 - { 64 64 - struct strvec vec = STRVEC_INIT; 65 65 - strvec_pushf(&vec, "foo: %d", 1); 66 66 - check_strvec(&vec, "foo: 1", NULL); 67 67 - strvec_clear(&vec); 68 68 - } 60 60 + if_test ("pushf") { 61 61 + struct strvec vec = STRVEC_INIT; 62 62 + strvec_pushf(&vec, "foo: %d", 1); 63 63 + check_strvec(&vec, "foo: 1", NULL); 64 64 + strvec_clear(&vec); 65 65 + } 69 66 70 70 - static void t_pushl(void) 71 71 - { 72 72 - struct strvec vec = STRVEC_INIT; 73 73 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 74 74 - check_strvec(&vec, "foo", "bar", "baz", NULL); 75 75 - strvec_clear(&vec); 76 76 - } 67 67 + if_test ("pushl") { 68 68 + struct strvec vec = STRVEC_INIT; 69 69 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 70 70 + check_strvec(&vec, "foo", "bar", "baz", NULL); 71 71 + strvec_clear(&vec); 72 72 + } 77 73 78 78 - static void t_pushv(void) 79 79 - { 80 80 - const char *strings[] = { 81 81 - "foo", "bar", "baz", NULL, 82 82 - }; 83 83 - struct strvec vec = STRVEC_INIT; 74 74 + if_test ("pushv") { 75 75 + const char *strings[] = { 76 76 + "foo", "bar", "baz", NULL, 77 77 + }; 78 78 + struct strvec vec = STRVEC_INIT; 84 79 85 85 - strvec_pushv(&vec, strings); 86 86 - check_strvec(&vec, "foo", "bar", "baz", NULL); 80 80 + strvec_pushv(&vec, strings); 81 81 + check_strvec(&vec, "foo", "bar", "baz", NULL); 87 82 88 88 - strvec_clear(&vec); 89 89 - } 83 83 + strvec_clear(&vec); 84 84 + } 90 85 91 91 - static void t_replace_at_head(void) 92 92 - { 93 93 - struct strvec vec = STRVEC_INIT; 94 94 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 95 95 - strvec_replace(&vec, 0, "replaced"); 96 96 - check_strvec(&vec, "replaced", "bar", "baz", NULL); 97 97 - strvec_clear(&vec); 98 98 - } 86 86 + if_test ("replace at head") { 87 87 + struct strvec vec = STRVEC_INIT; 88 88 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 89 89 + strvec_replace(&vec, 0, "replaced"); 90 90 + check_strvec(&vec, "replaced", "bar", "baz", NULL); 91 91 + strvec_clear(&vec); 92 92 + } 99 93 100 100 - static void t_replace_at_tail(void) 101 101 - { 102 102 - struct strvec vec = STRVEC_INIT; 103 103 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 104 104 - strvec_replace(&vec, 2, "replaced"); 105 105 - check_strvec(&vec, "foo", "bar", "replaced", NULL); 106 106 - strvec_clear(&vec); 107 107 - } 94 94 + if_test ("replace at tail") { 95 95 + struct strvec vec = STRVEC_INIT; 96 96 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 97 97 + strvec_replace(&vec, 2, "replaced"); 98 98 + check_strvec(&vec, "foo", "bar", "replaced", NULL); 99 99 + strvec_clear(&vec); 100 100 + } 108 101 109 109 - static void t_replace_in_between(void) 110 110 - { 111 111 - struct strvec vec = STRVEC_INIT; 112 112 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 113 113 - strvec_replace(&vec, 1, "replaced"); 114 114 - check_strvec(&vec, "foo", "replaced", "baz", NULL); 115 115 - strvec_clear(&vec); 116 116 - } 102 102 + if_test ("replace in between") { 103 103 + struct strvec vec = STRVEC_INIT; 104 104 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 105 105 + strvec_replace(&vec, 1, "replaced"); 106 106 + check_strvec(&vec, "foo", "replaced", "baz", NULL); 107 107 + strvec_clear(&vec); 108 108 + } 117 109 118 118 - static void t_replace_with_substring(void) 119 119 - { 120 120 - struct strvec vec = STRVEC_INIT; 121 121 - strvec_pushl(&vec, "foo", NULL); 122 122 - strvec_replace(&vec, 0, vec.v[0] + 1); 123 123 - check_strvec(&vec, "oo", NULL); 124 124 - strvec_clear(&vec); 125 125 - } 110 110 + if_test ("replace with substring") { 111 111 + struct strvec vec = STRVEC_INIT; 112 112 + strvec_pushl(&vec, "foo", NULL); 113 113 + strvec_replace(&vec, 0, vec.v[0] + 1); 114 114 + check_strvec(&vec, "oo", NULL); 115 115 + strvec_clear(&vec); 116 116 + } 126 117 127 127 - static void t_remove_at_head(void) 128 128 - { 129 129 - struct strvec vec = STRVEC_INIT; 130 130 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 131 131 - strvec_remove(&vec, 0); 132 132 - check_strvec(&vec, "bar", "baz", NULL); 133 133 - strvec_clear(&vec); 134 134 - } 118 118 + if_test ("remove at head") { 119 119 + struct strvec vec = STRVEC_INIT; 120 120 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 121 121 + strvec_remove(&vec, 0); 122 122 + check_strvec(&vec, "bar", "baz", NULL); 123 123 + strvec_clear(&vec); 124 124 + } 135 125 136 136 - static void t_remove_at_tail(void) 137 137 - { 138 138 - struct strvec vec = STRVEC_INIT; 139 139 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 140 140 - strvec_remove(&vec, 2); 141 141 - check_strvec(&vec, "foo", "bar", NULL); 142 142 - strvec_clear(&vec); 143 143 - } 126 126 + if_test ("remove at tail") { 127 127 + struct strvec vec = STRVEC_INIT; 128 128 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 129 129 + strvec_remove(&vec, 2); 130 130 + check_strvec(&vec, "foo", "bar", NULL); 131 131 + strvec_clear(&vec); 132 132 + } 144 133 145 145 - static void t_remove_in_between(void) 146 146 - { 147 147 - struct strvec vec = STRVEC_INIT; 148 148 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 149 149 - strvec_remove(&vec, 1); 150 150 - check_strvec(&vec, "foo", "baz", NULL); 151 151 - strvec_clear(&vec); 152 152 - } 134 134 + if_test ("remove in between") { 135 135 + struct strvec vec = STRVEC_INIT; 136 136 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 137 137 + strvec_remove(&vec, 1); 138 138 + check_strvec(&vec, "foo", "baz", NULL); 139 139 + strvec_clear(&vec); 140 140 + } 153 141 154 154 - static void t_pop_empty_array(void) 155 155 - { 156 156 - struct strvec vec = STRVEC_INIT; 157 157 - strvec_pop(&vec); 158 158 - check_strvec(&vec, NULL); 159 159 - strvec_clear(&vec); 160 160 - } 142 142 + if_test ("pop with empty array") { 143 143 + struct strvec vec = STRVEC_INIT; 144 144 + strvec_pop(&vec); 145 145 + check_strvec(&vec, NULL); 146 146 + strvec_clear(&vec); 147 147 + } 161 148 162 162 - static void t_pop_non_empty_array(void) 163 163 - { 164 164 - struct strvec vec = STRVEC_INIT; 165 165 - strvec_pushl(&vec, "foo", "bar", "baz", NULL); 166 166 - strvec_pop(&vec); 167 167 - check_strvec(&vec, "foo", "bar", NULL); 168 168 - strvec_clear(&vec); 169 169 - } 149 149 + if_test ("pop with non-empty array") { 150 150 + struct strvec vec = STRVEC_INIT; 151 151 + strvec_pushl(&vec, "foo", "bar", "baz", NULL); 152 152 + strvec_pop(&vec); 153 153 + check_strvec(&vec, "foo", "bar", NULL); 154 154 + strvec_clear(&vec); 155 155 + } 170 156 171 171 - static void t_split_empty_string(void) 172 172 - { 173 173 - struct strvec vec = STRVEC_INIT; 174 174 - strvec_split(&vec, ""); 175 175 - check_strvec(&vec, NULL); 176 176 - strvec_clear(&vec); 177 177 - } 157 157 + if_test ("split empty string") { 158 158 + struct strvec vec = STRVEC_INIT; 159 159 + strvec_split(&vec, ""); 160 160 + check_strvec(&vec, NULL); 161 161 + strvec_clear(&vec); 162 162 + } 178 163 179 179 - static void t_split_single_item(void) 180 180 - { 181 181 - struct strvec vec = STRVEC_INIT; 182 182 - strvec_split(&vec, "foo"); 183 183 - check_strvec(&vec, "foo", NULL); 184 184 - strvec_clear(&vec); 185 185 - } 164 164 + if_test ("split single item") { 165 165 + struct strvec vec = STRVEC_INIT; 166 166 + strvec_split(&vec, "foo"); 167 167 + check_strvec(&vec, "foo", NULL); 168 168 + strvec_clear(&vec); 169 169 + } 186 170 187 187 - static void t_split_multiple_items(void) 188 188 - { 189 189 - struct strvec vec = STRVEC_INIT; 190 190 - strvec_split(&vec, "foo bar baz"); 191 191 - check_strvec(&vec, "foo", "bar", "baz", NULL); 192 192 - strvec_clear(&vec); 193 193 - } 171 171 + if_test ("split multiple items") { 172 172 + struct strvec vec = STRVEC_INIT; 173 173 + strvec_split(&vec, "foo bar baz"); 174 174 + check_strvec(&vec, "foo", "bar", "baz", NULL); 175 175 + strvec_clear(&vec); 176 176 + } 194 177 195 195 - static void t_split_whitespace_only(void) 196 196 - { 197 197 - struct strvec vec = STRVEC_INIT; 198 198 - strvec_split(&vec, " \t\n"); 199 199 - check_strvec(&vec, NULL); 200 200 - strvec_clear(&vec); 201 201 - } 178 178 + if_test ("split whitespace only") { 179 179 + struct strvec vec = STRVEC_INIT; 180 180 + strvec_split(&vec, " \t\n"); 181 181 + check_strvec(&vec, NULL); 182 182 + strvec_clear(&vec); 183 183 + } 202 184 203 203 - static void t_split_multiple_consecutive_whitespaces(void) 204 204 - { 205 205 - struct strvec vec = STRVEC_INIT; 206 206 - strvec_split(&vec, "foo\n\t bar"); 207 207 - check_strvec(&vec, "foo", "bar", NULL); 208 208 - strvec_clear(&vec); 209 209 - } 185 185 + if_test ("split multiple consecutive whitespaces") { 186 186 + struct strvec vec = STRVEC_INIT; 187 187 + strvec_split(&vec, "foo\n\t bar"); 188 188 + check_strvec(&vec, "foo", "bar", NULL); 189 189 + strvec_clear(&vec); 190 190 + } 210 191 211 211 - static void t_detach(void) 212 212 - { 213 213 - struct strvec vec = STRVEC_INIT; 214 214 - const char **detached; 192 192 + if_test ("detach") { 193 193 + struct strvec vec = STRVEC_INIT; 194 194 + const char **detached; 215 195 216 216 - strvec_push(&vec, "foo"); 196 196 + strvec_push(&vec, "foo"); 217 197 218 218 - detached = strvec_detach(&vec); 219 219 - check_str(detached[0], "foo"); 220 220 - check_pointer_eq(detached[1], NULL); 198 198 + detached = strvec_detach(&vec); 199 199 + check_str(detached[0], "foo"); 200 200 + check_pointer_eq(detached[1], NULL); 221 201 222 222 - check_pointer_eq(vec.v, empty_strvec); 223 223 - check_uint(vec.nr, ==, 0); 224 224 - check_uint(vec.alloc, ==, 0); 202 202 + check_pointer_eq(vec.v, empty_strvec); 203 203 + check_uint(vec.nr, ==, 0); 204 204 + check_uint(vec.alloc, ==, 0); 225 205 226 226 - free((char *) detached[0]); 227 227 - free(detached); 228 228 - } 206 206 + free((char *) detached[0]); 207 207 + free(detached); 208 208 + } 229 209 230 230 - int cmd_main(int argc, const char **argv) 231 231 - { 232 232 - TEST(t_static_init(), "static initialization"); 233 233 - TEST(t_dynamic_init(), "dynamic initialization"); 234 234 - TEST(t_clear(), "clear"); 235 235 - TEST(t_push(), "push"); 236 236 - TEST(t_pushf(), "pushf"); 237 237 - TEST(t_pushl(), "pushl"); 238 238 - TEST(t_pushv(), "pushv"); 239 239 - TEST(t_replace_at_head(), "replace at head"); 240 240 - TEST(t_replace_in_between(), "replace in between"); 241 241 - TEST(t_replace_at_tail(), "replace at tail"); 242 242 - TEST(t_replace_with_substring(), "replace with substring"); 243 243 - TEST(t_remove_at_head(), "remove at head"); 244 244 - TEST(t_remove_in_between(), "remove in between"); 245 245 - TEST(t_remove_at_tail(), "remove at tail"); 246 246 - TEST(t_pop_empty_array(), "pop with empty array"); 247 247 - TEST(t_pop_non_empty_array(), "pop with non-empty array"); 248 248 - TEST(t_split_empty_string(), "split empty string"); 249 249 - TEST(t_split_single_item(), "split single item"); 250 250 - TEST(t_split_multiple_items(), "split multiple items"); 251 251 - TEST(t_split_whitespace_only(), "split whitespace only"); 252 252 - TEST(t_split_multiple_consecutive_whitespaces(), "split multiple consecutive whitespaces"); 253 253 - TEST(t_detach(), "detach"); 254 210 return test_done(); 255 211 }

+35 -1

t/unit-tests/test-lib.c

··· 16 16 unsigned running :1; 17 17 unsigned skip_all :1; 18 18 unsigned todo :1; 19 19 + char location[100]; 20 20 + char description[100]; 19 21 } ctx = { 20 22 .lazy_plan = 1, 21 23 .result = RESULT_NONE, ··· 125 127 126 128 int test_done(void) 127 129 { 130 130 + if (ctx.running && ctx.location[0] && ctx.description[0]) 131 131 + test__run_end(1, ctx.location, "%s", ctx.description); 128 132 assert(!ctx.running); 129 133 130 134 if (ctx.lazy_plan) ··· 167 171 va_end(ap); 168 172 } 169 173 174 174 + void test__run_describe(const char *location, const char *format, ...) 175 175 + { 176 176 + va_list ap; 177 177 + int len; 178 178 + 179 179 + assert(ctx.running); 180 180 + assert(!ctx.location[0]); 181 181 + assert(!ctx.description[0]); 182 182 + 183 183 + xsnprintf(ctx.location, sizeof(ctx.location), "%s", 184 184 + make_relative(location)); 185 185 + 186 186 + va_start(ap, format); 187 187 + len = vsnprintf(ctx.description, sizeof(ctx.description), format, ap); 188 188 + va_end(ap); 189 189 + if (len < 0) 190 190 + die("unable to format message: %s", format); 191 191 + if (len >= sizeof(ctx.description)) 192 192 + BUG("ctx.description too small to format %s", format); 193 193 + } 194 194 + 170 195 int test__run_begin(void) 171 196 { 197 197 + if (ctx.running && ctx.location[0] && ctx.description[0]) 198 198 + test__run_end(1, ctx.location, "%s", ctx.description); 172 199 assert(!ctx.running); 173 200 174 201 ctx.count++; 175 202 ctx.result = RESULT_NONE; 176 203 ctx.running = 1; 204 204 + ctx.location[0] = '\0'; 205 205 + ctx.description[0] = '\0'; 177 206 178 207 return ctx.skip_all; 179 208 } ··· 264 293 265 294 int test_assert(const char *location, const char *check, int ok) 266 295 { 267 267 - assert(ctx.running); 296 296 + if (!ctx.running) { 297 297 + test_msg("BUG: check outside of test at %s", 298 298 + make_relative(location)); 299 299 + ctx.failed = 1; 300 300 + return 0; 301 301 + } 268 302 269 303 if (ctx.result == RESULT_SKIP) { 270 304 test_msg("skipping check '%s' at %s", check,

+20

t/unit-tests/test-lib.h

··· 15 15 TEST_LOCATION(), __VA_ARGS__) 16 16 17 17 /* 18 18 + * Run a test unless test_skip_all() has been called. Acts like a 19 19 + * conditional; the test body is expected as a statement or block after 20 20 + * the closing parenthesis. The description for each test should be 21 21 + * unique. E.g.: 22 22 + * 23 23 + * if_test ("something else %d %d", arg1, arg2) { 24 24 + * prepare(); 25 25 + * test_something_else(arg1, arg2); 26 26 + * cleanup(); 27 27 + * } 28 28 + */ 29 29 + #define if_test(...) \ 30 30 + if (test__run_begin() ? \ 31 31 + (test__run_end(0, TEST_LOCATION(), __VA_ARGS__), 0) : \ 32 32 + (test__run_describe(TEST_LOCATION(), __VA_ARGS__), 1)) 33 33 + 34 34 + /* 18 35 * Print a test plan, should be called before any tests. If the number 19 36 * of tests is not known in advance test_done() will automatically 20 37 * print a plan at the end of the test program. ··· 153 170 }; 154 171 155 172 extern union test__tmp test__tmp[2]; 173 173 + 174 174 + __attribute__((format (printf, 2, 3))) 175 175 + void test__run_describe(const char *, const char *, ...); 156 176 157 177 int test__run_begin(void); 158 178 __attribute__((format (printf, 3, 4)))