diff --git a/lib/libsbuf/tests/sbuf_core_test.c b/lib/libsbuf/tests/sbuf_core_test.c index 117f178968ff..14bbc475043a 100644 --- a/lib/libsbuf/tests/sbuf_core_test.c +++ b/lib/libsbuf/tests/sbuf_core_test.c @@ -1,269 +1,269 @@ /*- * Copyright (c) 2017 Enji Cooper * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include + +#include #include #include #include #include #include #include -#include - #include "sbuf_test_common.h" -static char test_string[] = "this is a test string"; -#define TEST_STRING_CHOP_COUNT 5 +static char test_string[] = "this is a test string"; +#define TEST_STRING_CHOP_COUNT 5 _Static_assert(nitems(test_string) > TEST_STRING_CHOP_COUNT, "test_string is too short"); ATF_TC_WITHOUT_HEAD(sbuf_clear_test); ATF_TC_BODY(sbuf_clear_test, tc) { struct sbuf *sb; ssize_t buf_len; pid_t child_proc; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); /* * Cheat so we can get the contents of the buffer before calling * sbuf_finish(3) below, making additional sbuf changes impossible. */ child_proc = atf_utils_fork(); if (child_proc == 0) { ATF_REQUIRE_EQ_MSG(0, sbuf_finish(sb), "sbuf_finish failed: %s", strerror(errno)); sbuf_putbuf(sb); exit(0); } atf_utils_wait(child_proc, 0, test_string, ""); sbuf_clear(sb); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); buf_len = sbuf_len(sb); ATF_REQUIRE_MSG(buf_len == 0, "sbuf_len (%zd) != 0", buf_len); - ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), "", - "sbuf (\"%s\") was not empty", sbuf_data(sb)); + ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), "", "sbuf (\"%s\") was not empty", + sbuf_data(sb)); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_done_and_sbuf_finish_test); ATF_TC_BODY(sbuf_done_and_sbuf_finish_test, tc) { struct sbuf *sb; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_CHECK(sbuf_done(sb) == 0); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_CHECK(sbuf_done(sb) != 0); sbuf_delete(sb); } static int drain_ret0(void *arg, const char *data, int len) { - (void)arg; (void)data; (void)len; return (0); } ATF_TC_WITHOUT_HEAD(sbuf_drain_ret0_test); ATF_TC_BODY(sbuf_drain_ret0_test, tc) { struct sbuf *sb; sb = sbuf_new_auto(); sbuf_set_drain(sb, drain_ret0, NULL); sbuf_cat(sb, test_string); ATF_CHECK_EQ_MSG(-1, sbuf_finish(sb), "required to return error when drain func returns 0"); ATF_CHECK_EQ_MSG(EDEADLK, errno, "errno required to be EDEADLK when drain func returns 0"); } ATF_TC_WITHOUT_HEAD(sbuf_len_test); ATF_TC_BODY(sbuf_len_test, tc) { struct sbuf *sb; ssize_t buf_len, test_string_len; int i; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); test_string_len = strlen(test_string); for (i = 0; i < 20; i++) { buf_len = sbuf_len(sb); ATF_REQUIRE_MSG(buf_len == (ssize_t)(i * test_string_len), "sbuf_len (%zd) != %zu", buf_len, i * test_string_len); - ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); + ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, + "sbuf_cat failed"); } -#ifdef HAVE_SBUF_SET_FLAGS +#ifdef HAVE_SBUF_SET_FLAGS sbuf_set_flags(sb, SBUF_INCLUDENUL); ATF_REQUIRE_MSG((ssize_t)(i * test_string_len + 1) == sbuf_len(sb), "sbuf_len(..) didn't report the NUL char"); #endif ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_new_fixedlen); ATF_TC_BODY(sbuf_new_fixedlen, tc) { char buf[strlen(test_string) + 1]; struct sbuf sb; pid_t child_proc; sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN); sbuf_cat(&sb, test_string); child_proc = atf_utils_fork(); if (child_proc == 0) { - ATF_REQUIRE_EQ_MSG(0, sbuf_finish(&sb), "sbuf_finish failed: %s", - strerror(errno)); + ATF_REQUIRE_EQ_MSG(0, sbuf_finish(&sb), + "sbuf_finish failed: %s", strerror(errno)); sbuf_putbuf(&sb); exit(0); } atf_utils_wait(child_proc, 0, test_string, ""); sbuf_putc(&sb, ' '); - ATF_CHECK_EQ_MSG(-1, sbuf_finish(&sb), "failed to return error on overflow"); + ATF_CHECK_EQ_MSG(-1, sbuf_finish(&sb), + "failed to return error on overflow"); sbuf_delete(&sb); } ATF_TC_WITHOUT_HEAD(sbuf_setpos_test); ATF_TC_BODY(sbuf_setpos_test, tc) { struct sbuf *sb; size_t test_string_chopped_len, test_string_len; ssize_t buf_len; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); /* * An obvious sanity check -- if sbuf_len(..) lies, these invariants * are impossible to test. */ ATF_REQUIRE(sbuf_len(sb) == 0); ATF_CHECK(sbuf_setpos(sb, -1) == -1); ATF_CHECK(sbuf_setpos(sb, 0) == 0); ATF_CHECK(sbuf_setpos(sb, 1) == -1); ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); buf_len = sbuf_len(sb); test_string_len = strlen(test_string); test_string_chopped_len = test_string_len - TEST_STRING_CHOP_COUNT; ATF_REQUIRE_MSG(buf_len == (ssize_t)test_string_len, "sbuf length (%zd) != test_string length (%zu)", buf_len, test_string_len); /* Out of bounds (under length) */ ATF_CHECK(sbuf_setpos(sb, -1) == -1); /* * Out of bounds (over length) * * Note: SBUF_INCLUDENUL not set, so take '\0' into account. */ ATF_CHECK(sbuf_setpos(sb, test_string_len + 2) == -1); /* Within bounds */ ATF_CHECK(sbuf_setpos(sb, test_string_chopped_len) == 0); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); buf_len = sbuf_len(sb); ATF_REQUIRE_MSG(buf_len == (ssize_t)test_string_chopped_len, "sbuf_setpos didn't truncate string as expected"); ATF_REQUIRE_MSG(strncmp(sbuf_data(sb), test_string, buf_len) == 0, "sbuf (\"%s\") != test string (\"%s\") for [0,%zd]", sbuf_data(sb), test_string, buf_len); sbuf_delete(sb); } ATF_TP_ADD_TCS(tp) { - ATF_TP_ADD_TC(tp, sbuf_clear_test); ATF_TP_ADD_TC(tp, sbuf_done_and_sbuf_finish_test); ATF_TP_ADD_TC(tp, sbuf_drain_ret0_test); ATF_TP_ADD_TC(tp, sbuf_len_test); ATF_TP_ADD_TC(tp, sbuf_new_fixedlen); #if 0 /* TODO */ -#ifdef HAVE_SBUF_CLEAR_FLAGS +#ifdef HAVE_SBUF_CLEAR_FLAGS ATF_TP_ADD_TC(tp, sbuf_clear_flags_test); #endif -#ifdef HAVE_SBUF_GET_FLAGS +#ifdef HAVE_SBUF_GET_FLAGS ATF_TP_ADD_TC(tp, sbuf_get_flags_test); #endif ATF_TP_ADD_TC(tp, sbuf_new_positive_test); ATF_TP_ADD_TC(tp, sbuf_new_negative_test); -#ifdef HAVE_SBUF_SET_FLAGS +#ifdef HAVE_SBUF_SET_FLAGS ATF_TP_ADD_TC(tp, sbuf_set_flags_test); #endif #endif ATF_TP_ADD_TC(tp, sbuf_setpos_test); return (atf_no_error()); } diff --git a/lib/libsbuf/tests/sbuf_stdio_test.c b/lib/libsbuf/tests/sbuf_stdio_test.c index ee68c6c5a51d..8d8e01a962b9 100644 --- a/lib/libsbuf/tests/sbuf_stdio_test.c +++ b/lib/libsbuf/tests/sbuf_stdio_test.c @@ -1,214 +1,213 @@ /*- * Copyright (c) 2017 Enji Cooper * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include + +#include #include #include #include #include #include #include -#include - #include "sbuf_test_common.h" -static char test_string[] = "this is a test string"; +static char test_string[] = "this is a test string"; -#define MESSAGE_FORMAT "message: %s\n" -#define MESSAGE_SEPARATOR ';' +#define MESSAGE_FORMAT "message: %s\n" +#define MESSAGE_SEPARATOR ';' static int -sbuf_vprintf_helper(struct sbuf *sb, const char * restrict format, ...) +sbuf_vprintf_helper(struct sbuf *sb, const char *restrict format, ...) { va_list ap; int rc; va_start(ap, format); rc = sbuf_vprintf(sb, format, ap); va_end(ap); return (rc); } ATF_TC_WITHOUT_HEAD(sbuf_printf_drain_null_test); ATF_TC_BODY(sbuf_printf_drain_null_test, tc) { struct sbuf *sb; char buf[2]; pid_t child_proc; sb = sbuf_new(NULL, buf, sizeof(buf), SBUF_FIXEDLEN); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); child_proc = atf_utils_fork(); if (child_proc == 0) { sbuf_set_drain(sb, sbuf_printf_drain, NULL); ATF_REQUIRE_EQ_MSG(0, sbuf_cat(sb, test_string), "sbuf_cat failed"); ATF_CHECK_EQ(0, sbuf_finish(sb)); exit(0); } atf_utils_wait(child_proc, 0, test_string, ""); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_printf_drain_test); ATF_TC_BODY(sbuf_printf_drain_test, tc) { struct sbuf *sb; char buf[2]; pid_t child_proc; size_t cnt = 0; sb = sbuf_new(NULL, buf, sizeof(buf), SBUF_FIXEDLEN); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); child_proc = atf_utils_fork(); if (child_proc == 0) { sbuf_set_drain(sb, sbuf_printf_drain, &cnt); ATF_REQUIRE_EQ_MSG(0, sbuf_cat(sb, test_string), "sbuf_cat failed"); ATF_CHECK_EQ(0, sbuf_finish(sb)); ATF_CHECK_EQ(strlen(test_string), cnt); exit(0); } atf_utils_wait(child_proc, 0, test_string, ""); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_printf_test); ATF_TC_BODY(sbuf_printf_test, tc) { struct sbuf *sb; char *test_string_tmp; - asprintf(&test_string_tmp, "%s%c" MESSAGE_FORMAT, - test_string, MESSAGE_SEPARATOR, test_string); + asprintf(&test_string_tmp, "%s%c" MESSAGE_FORMAT, test_string, + MESSAGE_SEPARATOR, test_string); ATF_REQUIRE_MSG(test_string_tmp != NULL, "asprintf failed"); sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); ATF_REQUIRE_MSG(sbuf_putc(sb, MESSAGE_SEPARATOR) == 0, "sbuf_putc failed"); ATF_REQUIRE_MSG(sbuf_printf(sb, MESSAGE_FORMAT, test_string) == 0, "sbuf_printf failed"); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), test_string_tmp, "sbuf (\"%s\") != test string (\"%s\")", sbuf_data(sb), test_string_tmp); sbuf_delete(sb); free(test_string_tmp); } ATF_TC_WITHOUT_HEAD(sbuf_putbuf_test); ATF_TC_BODY(sbuf_putbuf_test, tc) { struct sbuf *sb; pid_t child_proc; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); child_proc = atf_utils_fork(); if (child_proc == 0) { ATF_CHECK_EQ(0, sbuf_finish(sb)); sbuf_putbuf(sb); exit(0); } atf_utils_wait(child_proc, 0, test_string, ""); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_vprintf_test); ATF_TC_BODY(sbuf_vprintf_test, tc) { struct sbuf *sb; char *test_string_tmp; int rc; - asprintf(&test_string_tmp, "%s%c" MESSAGE_FORMAT, - test_string, MESSAGE_SEPARATOR, test_string); + asprintf(&test_string_tmp, "%s%c" MESSAGE_FORMAT, test_string, + MESSAGE_SEPARATOR, test_string); ATF_REQUIRE_MSG(test_string_tmp != NULL, "asprintf failed"); sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); ATF_REQUIRE_MSG(sbuf_putc(sb, MESSAGE_SEPARATOR) == 0, "sbuf_putc failed"); rc = sbuf_vprintf_helper(sb, MESSAGE_FORMAT, test_string); ATF_REQUIRE_MSG(rc == 0, "sbuf_vprintf failed"); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), test_string_tmp, "sbuf (\"%s\") != test string (\"%s\")", sbuf_data(sb), test_string_tmp); sbuf_delete(sb); } ATF_TP_ADD_TCS(tp) { - ATF_TP_ADD_TC(tp, sbuf_printf_drain_null_test); ATF_TP_ADD_TC(tp, sbuf_printf_drain_test); ATF_TP_ADD_TC(tp, sbuf_printf_test); ATF_TP_ADD_TC(tp, sbuf_putbuf_test); ATF_TP_ADD_TC(tp, sbuf_vprintf_test); return (atf_no_error()); } diff --git a/lib/libsbuf/tests/sbuf_string_test.c b/lib/libsbuf/tests/sbuf_string_test.c index 37c1c1805b7b..fddaaac9886a 100644 --- a/lib/libsbuf/tests/sbuf_string_test.c +++ b/lib/libsbuf/tests/sbuf_string_test.c @@ -1,285 +1,289 @@ /*- * Copyright (c) 2017 Enji Cooper * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include + +#include #include #include #include #include #include -#include - #include "sbuf_test_common.h" -static char test_string[] = "this is a test string"; -static char test_whitespace_string[] = " \f\n\r\t\v "; -static int test_buffer[] = { 0, 1, 2, 3, 4, 5, }; +static char test_string[] = "this is a test string"; +static char test_whitespace_string[] = " \f\n\r\t\v "; +static int test_buffer[] = { + 0, + 1, + 2, + 3, + 4, + 5, +}; static void check_buffers_equal(const void *sb_buf, const void *test_buf, size_t len) { - if (memcmp(sb_buf, test_buf, len) != 0) { printf("sbuf:\n"); - hexdump(sb_buf, len, NULL, 0), - printf("test_buf:\n"); + hexdump(sb_buf, len, NULL, 0), printf("test_buf:\n"); hexdump(test_buf, len, NULL, 0); atf_tc_fail("contents of sbuf didn't match test_buf contents"); } } ATF_TC_WITHOUT_HEAD(sbuf_bcat_test); ATF_TC_BODY(sbuf_bcat_test, tc) { struct sbuf *sb; int *test_buffer_tmp; ssize_t test_sbuf_len; test_buffer_tmp = malloc(sizeof(test_buffer) * 2); ATF_REQUIRE_MSG(test_buffer_tmp != NULL, "malloc failed"); memcpy(test_buffer_tmp, test_buffer, sizeof(test_buffer)); memcpy(&test_buffer_tmp[nitems(test_buffer)], test_buffer, sizeof(test_buffer)); sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_CHECK_MSG(sbuf_bcat(sb, test_buffer, sizeof(test_buffer)) == 0, "sbuf_bcat failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)sizeof(test_buffer), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, sizeof(test_buffer)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + sizeof(test_buffer)); ATF_CHECK_MSG(sbuf_bcat(sb, test_buffer, sizeof(test_buffer)) == 0, "sbuf_bcat failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)(2 * sizeof(test_buffer)), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, 2 * sizeof(test_buffer)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + 2 * sizeof(test_buffer)); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); check_buffers_equal(sbuf_data(sb), test_buffer_tmp, (size_t)test_sbuf_len); sbuf_delete(sb); free(test_buffer_tmp); } ATF_TC_WITHOUT_HEAD(sbuf_bcpy_test); ATF_TC_BODY(sbuf_bcpy_test, tc) { struct sbuf *sb; ssize_t test_sbuf_len; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_CHECK_MSG(sbuf_bcpy(sb, test_buffer, sizeof(test_buffer)) == 0, "sbuf_bcpy failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)sizeof(test_buffer), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, sizeof(test_buffer)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + sizeof(test_buffer)); ATF_CHECK_MSG(sbuf_bcpy(sb, test_buffer, sizeof(test_buffer)) == 0, "sbuf_bcpy failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)sizeof(test_buffer), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, sizeof(test_buffer)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + sizeof(test_buffer)); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); check_buffers_equal(sbuf_data(sb), test_buffer, (size_t)test_sbuf_len); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_cat_test); ATF_TC_BODY(sbuf_cat_test, tc) { struct sbuf *sb; char *test_string_tmp; ssize_t test_sbuf_len; asprintf(&test_string_tmp, "%s%s", test_string, test_string); ATF_REQUIRE_MSG(test_string_tmp != NULL, "asprintf failed"); sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_CHECK_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)strlen(test_string), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, sizeof(test_string)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + sizeof(test_string)); ATF_CHECK_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)strlen(test_string_tmp), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, strlen(test_string_tmp)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + strlen(test_string_tmp)); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), test_string_tmp, "sbuf (\"%s\") != test string (\"%s\")", sbuf_data(sb), test_string_tmp); sbuf_delete(sb); free(test_string_tmp); } ATF_TC_WITHOUT_HEAD(sbuf_cpy_test); ATF_TC_BODY(sbuf_cpy_test, tc) { struct sbuf *sb; ssize_t test_sbuf_len; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_CHECK_MSG(sbuf_cpy(sb, test_string) == 0, "sbuf_cpy failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)strlen(test_string), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, strlen(test_string)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + strlen(test_string)); ATF_CHECK_MSG(sbuf_cpy(sb, test_string) == 0, "sbuf_cpy failed"); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(test_sbuf_len == (ssize_t)strlen(test_string), - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, strlen(test_string)); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + strlen(test_string)); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), test_string, "sbuf (\"%s\") != test string (\"%s\")", sbuf_data(sb), test_string); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_putc_test); ATF_TC_BODY(sbuf_putc_test, tc) { struct sbuf *sb; ssize_t test_sbuf_len; size_t i; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); - for (i = 0; i <= strlen(test_string); i++) { /* Include the NUL */ + for (i = 0; i <= strlen(test_string); i++) { /* Include the NUL */ ATF_REQUIRE_MSG(sbuf_putc(sb, test_string[i]) == 0, "sbuf_putc failed"); /* The best we can do until sbuf_finish(3) is called. */ test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG((ssize_t)(i + 1) == test_sbuf_len, "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, i + 1); } ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), test_string, "sbuf (\"%s\") != test string (\"%s\")", sbuf_data(sb), test_string); sbuf_delete(sb); } ATF_TC_WITHOUT_HEAD(sbuf_trim_test); ATF_TC_BODY(sbuf_trim_test, tc) { struct sbuf *sb; ssize_t exp_sbuf_len, test_sbuf_len; sb = sbuf_new_auto(); ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s", strerror(errno)); ATF_CHECK_MSG(sbuf_cpy(sb, test_string) == 0, "sbuf_cpy failed"); ATF_CHECK_MSG(sbuf_cat(sb, test_whitespace_string) == 0, "sbuf_cat failed"); /* The best we can do until sbuf_finish(3) is called. */ exp_sbuf_len = (ssize_t)(strlen(test_string) + strlen(test_whitespace_string)); test_sbuf_len = sbuf_len(sb); ATF_REQUIRE_MSG(exp_sbuf_len == test_sbuf_len, - "sbuf_len(..) => %zd (actual) != %zu (expected)", - test_sbuf_len, exp_sbuf_len); + "sbuf_len(..) => %zd (actual) != %zu (expected)", test_sbuf_len, + exp_sbuf_len); ATF_REQUIRE_MSG(sbuf_trim(sb) == 0, "sbuf_trim failed"); ATF_REQUIRE_MSG(sbuf_finish(sb) == 0, "sbuf_finish failed: %s", strerror(errno)); ATF_REQUIRE_STREQ_MSG(sbuf_data(sb), test_string, "sbuf (\"%s\") != test string (\"%s\") (trimmed)", sbuf_data(sb), test_string); sbuf_delete(sb); } ATF_TP_ADD_TCS(tp) { - ATF_TP_ADD_TC(tp, sbuf_bcat_test); ATF_TP_ADD_TC(tp, sbuf_bcpy_test); ATF_TP_ADD_TC(tp, sbuf_cat_test); ATF_TP_ADD_TC(tp, sbuf_cpy_test); ATF_TP_ADD_TC(tp, sbuf_putc_test); ATF_TP_ADD_TC(tp, sbuf_trim_test); return (atf_no_error()); }