diff options
Diffstat (limited to 'lib/libsbuf/tests')
| -rw-r--r-- | lib/libsbuf/tests/Makefile | 11 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_core_test.c | 211 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_stdio_test.c | 160 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_string_test.c | 288 | ||||
| -rw-r--r-- | lib/libsbuf/tests/sbuf_test_common.h | 40 |
5 files changed, 710 insertions, 0 deletions
diff --git a/lib/libsbuf/tests/Makefile b/lib/libsbuf/tests/Makefile new file mode 100644 index 000000000000..d3532f01b7b6 --- /dev/null +++ b/lib/libsbuf/tests/Makefile @@ -0,0 +1,11 @@ +# $FreeBSD$ + +ATF_TESTS_C+= sbuf_core_test +ATF_TESTS_C+= sbuf_stdio_test +ATF_TESTS_C+= sbuf_string_test + +LIBADD+= sbuf util + +WARNS?= 6 + +.include <bsd.test.mk> diff --git a/lib/libsbuf/tests/sbuf_core_test.c b/lib/libsbuf/tests/sbuf_core_test.c new file mode 100644 index 000000000000..9fc040173079 --- /dev/null +++ b/lib/libsbuf/tests/sbuf_core_test.c @@ -0,0 +1,211 @@ +/*- + * Copyright (c) 2017 Ngie Cooper <ngie@freebsd.org> + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/sbuf.h> +#include <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <atf-c.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) { + 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); +} + +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_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_len_test); +#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..b2165fbf94ff --- /dev/null +++ b/lib/libsbuf/tests/sbuf_stdio_test.c @@ -0,0 +1,160 @@ +/*- + * Copyright (c) 2017 Ngie Cooper <ngie@freebsd.org> + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/sbuf.h> +#include <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <atf-c.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_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) { + 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_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..b3828850ca54 --- /dev/null +++ b/lib/libsbuf/tests/sbuf_string_test.c @@ -0,0 +1,288 @@ +/*- + * Copyright (c) 2017 Ngie Cooper <ngie@freebsd.org> + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/sbuf.h> +#include <errno.h> +#include <libutil.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <atf-c.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..4566195cf80a --- /dev/null +++ b/lib/libsbuf/tests/sbuf_test_common.h @@ -0,0 +1,40 @@ +/*- + * Copyright (c) 2017 Ngie Cooper <ngie@freebsd.org> + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#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 |