X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=tests%2Fstrutil.c;h=3e43dbdca2c2ba2a278c6e72b6306656da33be88;hp=0138fa9dffcfa2a9712d0cddf1653b39c51d06b1;hb=HEAD;hpb=16e88c6b93d164f4c4e7c437f907789ed27281ad diff --git a/tests/strutil.c b/tests/strutil.c index 0138fa9d..3e43dbdc 100644 --- a/tests/strutil.c +++ b/tests/strutil.c @@ -19,6 +19,7 @@ #include #include +#include #include #include #include "lib.h" @@ -37,9 +38,10 @@ static void test_vsnprintf(const char *expected, char *format, ...) len = vsnprintf(s, len, format, args); va_end(args); - fail_unless(s != NULL, "len = %i, s = s", len); + fail_unless(s != NULL, + "Invalid result for '%s': len = %i.", expected, len); fail_unless(!strcmp(s, expected), - "Invalid result for '%s': %s.", expected, s); + "Invalid result for '%s': %s.", expected, s); g_free(s); } #endif @@ -57,7 +59,32 @@ static void test_sr_vsnprintf_ascii(const char *expected, char *format, ...) len = sr_vsnprintf_ascii(s, len, format, args); va_end(args); - fail_unless(s != NULL, "len = %i, s = s", len); + fail_unless(s != NULL, + "Invalid result for '%s': len = %i.", expected, len); + fail_unless(!strcmp(s, expected), + "Invalid result for '%s': %s.", expected, s); + g_free(s); +} + +static void test_sr_vsprintf_ascii(const char *expected, char *format, ...) +{ + va_list args, args_copy; + char *s; + int len; + + /* Get length of buffer required. */ + va_start(args, format); + va_copy(args_copy, args); + len = sr_vsnprintf_ascii(NULL, 0, format, args); + va_end(args); + + /* Allocate buffer and write out command. */ + s = g_malloc0(len + 1); + len = sr_vsprintf_ascii(s, format, args_copy); + va_end(args_copy); + + fail_unless(s != NULL, + "Invalid result for '%s': len = %i.", expected, len); fail_unless(!strcmp(s, expected), "Invalid result for '%s': %s.", expected, s); g_free(s); @@ -91,12 +118,22 @@ static void test_rational(const char *input, struct sr_rational expected) struct sr_rational rational; ret = sr_parse_rational(input, &rational); - fail_unless(ret == SR_OK); + fail_unless(ret == SR_OK, "Unexpected rc for '%s': %d, errno %d.", + input, ret, errno); fail_unless((expected.p == rational.p) && (expected.q == rational.q), - "Invalid result for '%s': %ld/%ld'.", + "Invalid result for '%s': %" PRIi64 "/%" PRIu64 "'.", input, rational.p, rational.q); } +static void test_rational_fail(const char *input) +{ + int ret; + struct sr_rational rational; + + ret = sr_parse_rational(input, &rational); + fail_unless(ret != SR_OK, "Unexpected success for '%s'.", input); +} + static void test_voltage(uint64_t v_p, uint64_t v_q, const char *expected) { char *s; @@ -117,7 +154,7 @@ START_TEST(test_locale) fprintf(stderr, "Old locale = %s\n", old_locale); /* Copy the name so it won’t be clobbered by setlocale. */ saved_locale = g_strdup(old_locale); - ck_assert_msg(saved_locale != NULL); + ck_assert(saved_locale != NULL); #ifdef _WIN32 /* @@ -144,6 +181,13 @@ START_TEST(test_locale) test_sr_vsnprintf_ascii("0.12345", "%.5f", (double)0.12345); test_sr_vsnprintf_ascii("0.123456", "%.6f", (double)0.123456); + test_sr_vsprintf_ascii("0.1", "%.1f", (double)0.1); + test_sr_vsprintf_ascii("0.12", "%.2f", (double)0.12); + test_sr_vsprintf_ascii("0.123", "%.3f", (double)0.123); + test_sr_vsprintf_ascii("0.1234", "%.4f", (double)0.1234); + test_sr_vsprintf_ascii("0.12345", "%.5f", (double)0.12345); + test_sr_vsprintf_ascii("0.123456", "%.6f", (double)0.123456); + #if 0 /* * These tests can be used to tell on which platforms the printf() @@ -251,19 +295,17 @@ END_TEST START_TEST(test_ghz) { - /* Note: Numbers > 2^32 need a ULL suffix. */ - - test_samplerate(1000000000, "1 GHz"); - test_samplerate(5000000000ULL, "5 GHz"); - test_samplerate(72000000000ULL, "72 GHz"); - test_samplerate(388000000000ULL, "388 GHz"); - test_samplerate(4417594444ULL, "4.417594444 GHz"); - test_samplerate(44175944444ULL, "44.175944444 GHz"); - test_samplerate(441759444441ULL, "441.759444441 GHz"); - test_samplerate(441759000001ULL, "441.759000001 GHz"); - test_samplerate(441050000000ULL, "441.05 GHz"); - test_samplerate(441000000005ULL, "441.000000005 GHz"); - test_samplerate(441500000000ULL, "441.5 GHz"); + test_samplerate(UINT64_C(1000000000), "1 GHz"); + test_samplerate(UINT64_C(5000000000), "5 GHz"); + test_samplerate(UINT64_C(72000000000), "72 GHz"); + test_samplerate(UINT64_C(388000000000), "388 GHz"); + test_samplerate(UINT64_C(4417594444), "4.417594444 GHz"); + test_samplerate(UINT64_C(44175944444), "44.175944444 GHz"); + test_samplerate(UINT64_C(441759444441), "441.759444441 GHz"); + test_samplerate(UINT64_C(441759000001), "441.759000001 GHz"); + test_samplerate(UINT64_C(441050000000), "441.05 GHz"); + test_samplerate(UINT64_C(441000000005), "441.000000005 GHz"); + test_samplerate(UINT64_C(441500000000), "441.5 GHz"); /* Again, but now using SR_GHZ(). */ test_samplerate(SR_GHZ(1), "1 GHz"); @@ -279,8 +321,8 @@ START_TEST(test_ghz) test_samplerate(SR_GHZ(441.500000000), "441.5 GHz"); /* Now check the biggest-possible samplerate (2^64 Hz). */ - // test_samplerate(18446744073709551615ULL, "18446744073.709551615 GHz"); - // test_samplerate(SR_GHZ(18446744073ULL), "18446744073 GHz"); + // test_samplerate(UINT64_C(18446744073709551615), "18446744073.709551615 GHz"); + // test_samplerate(SR_GHZ(UINT64_C(18446744073)), "18446744073 GHz"); } END_TEST @@ -303,13 +345,12 @@ END_TEST START_TEST(test_ghz_period) { - /* Note: Numbers > 2^32 need a ULL suffix. */ - test_period(1, 1000000000, "1 ns"); - test_period(1, 5000000000ULL, "200 ps"); - test_period(1, 72000000000ULL, "13.889 ps"); - test_period(1, 388000000000ULL, "2.577 ps"); - test_period(10, 1000000000000, "10 ps"); - test_period(200, 1000000000000ULL, "200 ps"); + test_period(1, UINT64_C(1000000000), "1 ns"); + test_period(1, UINT64_C(5000000000), "200 ps"); + test_period(1, UINT64_C(72000000000), "13.889 ps"); + test_period(1, UINT64_C(388000000000), "2.577 ps"); + test_period(10, UINT64_C(1000000000000), "10 ps"); + test_period(200, UINT64_C(1000000000000), "200 ps"); /* Again, but now using SR_GHZ(). */ test_period(1, SR_GHZ(1), "1 ns"); @@ -356,6 +397,16 @@ START_TEST(test_fractional) test_rational("+.1", (struct sr_rational){1, 10}); test_rational("-0.1", (struct sr_rational){-1, 10}); test_rational("-.1", (struct sr_rational){-1, 10}); + test_rational(".1", (struct sr_rational){1, 10}); + test_rational(".123", (struct sr_rational){123, 1000}); + test_rational("1.", (struct sr_rational){1, 1}); + test_rational("123.", (struct sr_rational){123, 1}); + test_rational("-.1", (struct sr_rational){-1, 10}); + test_rational(" .1", (struct sr_rational){1, 10}); + test_rational("+.1", (struct sr_rational){1, 10}); + test_rational_fail("."); + test_rational_fail(".e"); + test_rational_fail(".e1"); } END_TEST @@ -379,6 +430,184 @@ START_TEST(test_exponent) } END_TEST +START_TEST(test_text_line) +{ + /* + * Covers text line splitting as used in input modules. Accepts + * input with differing end-of-line conventions, accepts leading + * and trailing whitespace. Isolates "the core" of a text line. + * Supports repeated calls which accumulate what later needs to + * get discarded after input data got processed in pieces. + */ +#define EOL "\n" + +#define TEXT_CORE_1 "Need to provide" +#define TEXT_CORE_2 "an input text" +#define TEXT_CORE_3 "" +#define TEXT_CORE_4 "with empty lines and funny spacing perhaps?" + +#define TEXT_LINE_1 TEXT_CORE_1 " \n" +#define TEXT_LINE_2 " " TEXT_CORE_2 "\n" +#define TEXT_LINE_3 TEXT_CORE_3 "\r\n" +#define TEXT_LINE_4 TEXT_CORE_4 "\n" + +#define TEXT_INPUT TEXT_LINE_1 TEXT_LINE_2 TEXT_LINE_3 TEXT_LINE_4 + + char *input_text, *read_pos, *next_pos, *line; + size_t input_len, taken; + + input_text = g_strdup(TEXT_INPUT); + read_pos = input_text; + input_len = strlen(input_text); + + /* Cover first line in tests. */ + taken = 0; + line = sr_text_next_line(read_pos, input_len, &next_pos, &taken); + fail_unless(line, "Text line not found"); + fail_unless(strcmp(line, TEXT_CORE_1) == 0, "Unexpected line content"); + fail_unless(next_pos, "No next line found"); + fail_unless(strncmp(next_pos, TEXT_LINE_2, strlen(TEXT_LINE_2)) == 0, + "Unexpected next line content"); + fail_unless(taken == strlen(TEXT_LINE_1), + "Unexpected consumed count"); + read_pos = next_pos; + input_len -= taken; + taken = 0; + + /* Cover second line in tests. DO NOT void 'taken' yet. */ + line = sr_text_next_line(read_pos, input_len, &next_pos, &taken); + fail_unless(line, "Text line not found"); + fail_unless(strcmp(line, TEXT_CORE_2) == 0, + "Unexpected text line content"); + fail_unless(next_pos, "No next line found"); + fail_unless(strncmp(next_pos, TEXT_LINE_3, strlen(TEXT_LINE_3)) == 0, + "Unexpected next line content"); + fail_unless(taken == strlen(TEXT_LINE_2), + "Unexpected consumed count"); + input_len -= next_pos - read_pos; + read_pos = next_pos; + + /* Cover third line in tests. Accumulates 'taken'. */ + line = sr_text_next_line(read_pos, input_len, &next_pos, &taken); + fail_unless(line, "Text line not found"); + fail_unless(strcmp(line, TEXT_CORE_3) == 0, "Unexpected line content"); + fail_unless(next_pos, "No next line found"); + fail_unless(strncmp(next_pos, TEXT_LINE_4, strlen(TEXT_LINE_4)) == 0, + "Unexpected next line content"); + fail_unless(taken == strlen(TEXT_LINE_2) + strlen(TEXT_LINE_3), + "Unexpected consumed count (totalled)"); + input_len -= next_pos - read_pos; + read_pos = next_pos; + taken = 0; + + /* Cover last line in tests. */ + line = sr_text_next_line(read_pos, input_len, &next_pos, &taken); + fail_unless(line, "Text line not found"); + fail_unless(strcmp(line, TEXT_CORE_4) == 0, + "Unexpected text line content"); + fail_unless(!next_pos, "Next line found, unexpected"); + fail_unless(taken == strlen(TEXT_LINE_4), + "Unexpected consumed count"); + input_len -= taken; + read_pos = next_pos; + + /* All input must have been consumed. */ + fail_unless(!read_pos); + fail_unless(!input_len); + + g_free(input_text); +} +END_TEST + +/* + * TODO Ideally this table of test cases should reside within the + * test_text_word() routine. But compilation fails when it's put there + * (initializers are said to not be constant, cause is yet uncertain). + */ +static const struct { + const char *line; + const char **words; +} word_cases[] = { + { "", (const char *[]){ NULL, }, }, + { " ", (const char *[]){ NULL, }, }, + { "one", (const char *[]){ "one", NULL, }, }, + { "one ", (const char *[]){ "one", NULL, }, }, + { " one ", (const char *[]){ "one", NULL, }, }, + { " one two ", (const char *[]){ "one", "two", NULL, }, }, + { "one two three ", + (const char *[]){ "one", "two", "three", NULL, }, + }, +}; + +START_TEST(test_text_word) +{ + size_t case_idx, word_idx; + char *line; + const char **words, *want; + char *read_pos, *next_pos, *have; + + for (case_idx = 0; case_idx < ARRAY_SIZE(word_cases); case_idx++) { + line = g_strdup(word_cases[case_idx].line); + words = word_cases[case_idx].words; + word_idx = 0; + + read_pos = line; + while (read_pos) { + want = words[word_idx]; + have = sr_text_next_word(read_pos, &next_pos); + if (!want) { + fail_unless(!have, "word found, unexpected"); + fail_unless(!next_pos, "next found after end"); + break; + } + word_idx++; + read_pos = next_pos; + fail_unless(have, "word not found"); + fail_unless(strcmp(have, want) == 0, + "unexpected word found"); + } + fail_unless(!words[word_idx], "missed expected words"); + + g_free(line); + } +} +END_TEST + +static const struct power_case_t { + size_t value; + size_t want_bits; + size_t want_power; +} power_cases[] = { + { 0, 1, 1, }, + { 1, 1, 2, }, + { 2, 2, 4, }, + { 3, 2, 4, }, + { 4, 3, 8, }, + { 5, 3, 8, }, + { 6, 3, 8, }, + { 7, 3, 8, }, + { 8, 4, 16, }, + { 15, 4, 16, }, + { 16, 5, 32, }, + { 31, 5, 32, }, +}; + +START_TEST(test_calc_power_of_two) +{ + size_t case_idx, bits, power; + const struct power_case_t *tcase; + int ret; + + for (case_idx = 0; case_idx < ARRAY_SIZE(power_cases); case_idx++) { + tcase = &power_cases[case_idx]; + ret = sr_next_power_of_two(tcase->value, &bits, &power); + fail_unless(ret == SR_OK, "bits count not found"); + fail_unless(bits == tcase->want_bits, "bits count differs"); + fail_unless(power == tcase->want_power, "power differs"); + } +} +END_TEST + Suite *suite_strutil(void) { Suite *s; @@ -401,5 +630,14 @@ Suite *suite_strutil(void) tcase_add_test(tc, test_exponent); suite_add_tcase(s, tc); + tc = tcase_create("text"); + tcase_add_test(tc, test_text_line); + tcase_add_test(tc, test_text_word); + suite_add_tcase(s, tc); + + tc = tcase_create("calc"); + tcase_add_test(tc, test_calc_power_of_two); + suite_add_tcase(s, tc); + return s; }