diff options
Diffstat (limited to 'lib/libsbuf/tests')
| -rw-r--r-- | lib/libsbuf/tests/Makefile | 7 | ||||
| -rw-r--r-- | lib/libsbuf/tests/Makefile.depend | 19 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_core_test.c | 269 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_stdio_test.c | 213 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_string_test.c | 289 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_test_common.h | 37 |
6 files changed, 834 insertions, 0 deletions
diff --git a/lib/libsbuf/tests/Makefile b/lib/libsbuf/tests/Makefile new file mode 100644 index 000000000000..512ca678cac3 --- /dev/null +++ b/lib/libsbuf/tests/Makefile @@ -0,0 +1,7 @@ +ATF_TESTS_C+= sbuf_core_test +ATF_TESTS_C+= sbuf_stdio_test +ATF_TESTS_C+= sbuf_string_test + +LIBADD+= sbuf util + +.include <bsd.test.mk> diff --git a/lib/libsbuf/tests/Makefile.depend b/lib/libsbuf/tests/Makefile.depend new file mode 100644 index 000000000000..f6d87575612e --- /dev/null +++ b/lib/libsbuf/tests/Makefile.depend @@ -0,0 +1,19 @@ +# Autogenerated - do NOT edit! + +DIRDEPS = \ + gnu/lib/csu \ + include \ + include/xlocale \ + lib/${CSU_DIR} \ + lib/atf/libatf-c \ + lib/libc \ + lib/libcompiler_rt \ + lib/libsbuf \ + lib/libutil \ + + +.include <dirdeps.mk> + +.if ${DEP_RELDIR} == ${_DEP_RELDIR} +# local dependencies - needed for -jN in clean tree +.endif diff --git a/lib/libsbuf/tests/sbuf_core_test.c b/lib/libsbuf/tests/sbuf_core_test.c new file mode 100644 index 000000000000..14bbc475043a --- /dev/null +++ b/lib/libsbuf/tests/sbuf_core_test.c @@ -0,0 +1,269 @@ +/*- + * Copyright (c) 2017 Enji Cooper <ngie@freebsd.org> + * + * 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 <sys/param.h> +#include <sys/sbuf.h> + +#include <atf-c.h> +#include <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "sbuf_test_common.h" + +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)); + + 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"); + } + +#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)); + + 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"); + + 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 + ATF_TP_ADD_TC(tp, sbuf_clear_flags_test); +#endif +#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 + 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 new file mode 100644 index 000000000000..8d8e01a962b9 --- /dev/null +++ b/lib/libsbuf/tests/sbuf_stdio_test.c @@ -0,0 +1,213 @@ +/*- + * Copyright (c) 2017 Enji Cooper <ngie@freebsd.org> + * + * 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 <sys/param.h> +#include <sys/sbuf.h> + +#include <atf-c.h> +#include <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "sbuf_test_common.h" + +static char test_string[] = "this is a test string"; + +#define MESSAGE_FORMAT "message: %s\n" +#define MESSAGE_SEPARATOR ';' + +static int +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); + 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); + 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 new file mode 100644 index 000000000000..fddaaac9886a --- /dev/null +++ b/lib/libsbuf/tests/sbuf_string_test.c @@ -0,0 +1,289 @@ +/*- + * Copyright (c) 2017 Enji Cooper <ngie@freebsd.org> + * + * 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 <sys/param.h> +#include <sys/sbuf.h> + +#include <atf-c.h> +#include <errno.h> +#include <libutil.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#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 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(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)); + + 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)); + + 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)); + + 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)); + + 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)); + + 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)); + + 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)); + + 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)); + + 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 */ + 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); + + 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()); +} diff --git a/lib/libsbuf/tests/sbuf_test_common.h b/lib/libsbuf/tests/sbuf_test_common.h new file mode 100644 index 000000000000..5c60abe2826e --- /dev/null +++ b/lib/libsbuf/tests/sbuf_test_common.h @@ -0,0 +1,37 @@ +/*- + * Copyright (c) 2017 Enji Cooper <ngie@freebsd.org> + * + * 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. + */ + +#ifndef __LIBSBUF_TEST_COMMON_H__ +#define __LIBSBUF_TEST_COMMON_H__ + +#include <sys/param.h> + +#if __FreeBSD_version > 1100064 +#define HAVE_SBUF_GET_FLAGS +#define HAVE_SBUF_CLEAR_FLAGS +#define HAVE_SBUF_SET_FLAGS +#endif + +#endif |