From 3b9b6d0b8e7f798023c9d109c490449d528fde80 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 17:59:48 +0200 Subject: Adding upstream version 1:9.18.19. Signed-off-by: Daniel Baumann --- tests/isc/buffer_test.c | 308 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 308 insertions(+) create mode 100644 tests/isc/buffer_test.c (limited to 'tests/isc/buffer_test.c') diff --git a/tests/isc/buffer_test.c b/tests/isc/buffer_test.c new file mode 100644 index 0000000..1c858d3 --- /dev/null +++ b/tests/isc/buffer_test.c @@ -0,0 +1,308 @@ +/* + * Copyright (C) Internet Systems Consortium, Inc. ("ISC") + * + * SPDX-License-Identifier: MPL-2.0 + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, you can obtain one at https://mozilla.org/MPL/2.0/. + * + * See the COPYRIGHT file distributed with this work for additional + * information regarding copyright ownership. + */ + +#include +#include +#include +#include /* IWYU pragma: keep */ +#include +#include +#include +#include +#include +#include +#include + +#define UNIT_TESTING +#include + +#include +#include +#include +#include +#include +#include + +#include + +/* reserve space in dynamic buffers */ +ISC_RUN_TEST_IMPL(isc_buffer_reserve) { + isc_result_t result; + isc_buffer_t *b; + + UNUSED(state); + + b = NULL; + isc_buffer_allocate(mctx, &b, 1024); + assert_int_equal(b->length, 1024); + + /* + * 1024 bytes should already be available, so this call does + * nothing. + */ + result = isc_buffer_reserve(&b, 1024); + assert_int_equal(result, ISC_R_SUCCESS); + assert_true(ISC_BUFFER_VALID(b)); + assert_non_null(b); + assert_int_equal(b->length, 1024); + + /* + * This call should grow it to 2048 bytes as only 1024 bytes are + * available in the buffer. + */ + result = isc_buffer_reserve(&b, 1025); + assert_int_equal(result, ISC_R_SUCCESS); + assert_true(ISC_BUFFER_VALID(b)); + assert_non_null(b); + assert_int_equal(b->length, 2048); + + /* + * 2048 bytes should already be available, so this call does + * nothing. + */ + result = isc_buffer_reserve(&b, 2000); + assert_int_equal(result, ISC_R_SUCCESS); + assert_true(ISC_BUFFER_VALID(b)); + assert_non_null(b); + assert_int_equal(b->length, 2048); + + /* + * This call should grow it to 4096 bytes as only 2048 bytes are + * available in the buffer. + */ + result = isc_buffer_reserve(&b, 3000); + assert_int_equal(result, ISC_R_SUCCESS); + assert_true(ISC_BUFFER_VALID(b)); + assert_non_null(b); + assert_int_equal(b->length, 4096); + + /* Consume some of the buffer so we can run the next test. */ + isc_buffer_add(b, 4096); + + /* + * This call should fail and leave buffer untouched. + */ + result = isc_buffer_reserve(&b, UINT_MAX); + assert_int_equal(result, ISC_R_NOMEMORY); + assert_true(ISC_BUFFER_VALID(b)); + assert_non_null(b); + assert_int_equal(b->length, 4096); + + isc_buffer_free(&b); +} + +/* dynamic buffer automatic reallocation */ +ISC_RUN_TEST_IMPL(isc_buffer_dynamic) { + isc_buffer_t *b; + size_t last_length = 10; + int i; + + UNUSED(state); + + b = NULL; + isc_buffer_allocate(mctx, &b, last_length); + assert_non_null(b); + assert_int_equal(b->length, last_length); + + isc_buffer_setautorealloc(b, true); + + isc_buffer_putuint8(b, 1); + + for (i = 0; i < 1000; i++) { + isc_buffer_putstr(b, "thisisa24charslongstring"); + } + assert_true(b->length - last_length >= 1000 * 24); + last_length += 1000 * 24; + + for (i = 0; i < 10000; i++) { + isc_buffer_putuint8(b, 1); + } + + assert_true(b->length - last_length >= 10000 * 1); + last_length += 10000 * 1; + + for (i = 0; i < 10000; i++) { + isc_buffer_putuint16(b, 1); + } + + assert_true(b->length - last_length >= 10000 * 2); + + last_length += 10000 * 2; + for (i = 0; i < 10000; i++) { + isc_buffer_putuint24(b, 1); + } + assert_true(b->length - last_length >= 10000 * 3); + + last_length += 10000 * 3; + + for (i = 0; i < 10000; i++) { + isc_buffer_putuint32(b, 1); + } + assert_true(b->length - last_length >= 10000 * 4); + + isc_buffer_free(&b); +} + +/* copy a region into a buffer */ +ISC_RUN_TEST_IMPL(isc_buffer_copyregion) { + unsigned char data[] = { 0x11, 0x22, 0x33, 0x44 }; + isc_buffer_t *b = NULL; + isc_result_t result; + + isc_region_t r = { + .base = data, + .length = sizeof(data), + }; + + UNUSED(state); + + isc_buffer_allocate(mctx, &b, sizeof(data)); + + /* + * Fill originally allocated buffer space. + */ + result = isc_buffer_copyregion(b, &r); + assert_int_equal(result, ISC_R_SUCCESS); + + /* + * Appending more data to the buffer should fail. + */ + result = isc_buffer_copyregion(b, &r); + assert_int_equal(result, ISC_R_NOSPACE); + + /* + * Enable auto reallocation and retry. Appending should now succeed. + */ + isc_buffer_setautorealloc(b, true); + result = isc_buffer_copyregion(b, &r); + assert_int_equal(result, ISC_R_SUCCESS); + + isc_buffer_free(&b); +} + +/* sprintf() into a buffer */ +ISC_RUN_TEST_IMPL(isc_buffer_printf) { + unsigned int used, prev_used; + const char *empty_fmt; + isc_result_t result; + isc_buffer_t *b, sb; + char buf[8]; + + UNUSED(state); + + /* + * Prepare a buffer with auto-reallocation enabled. + */ + b = NULL; + isc_buffer_allocate(mctx, &b, 0); + isc_buffer_setautorealloc(b, true); + + /* + * Sanity check. + */ + result = isc_buffer_printf(b, "foo"); + assert_int_equal(result, ISC_R_SUCCESS); + used = isc_buffer_usedlength(b); + assert_int_equal(used, 3); + + result = isc_buffer_printf(b, "bar"); + assert_int_equal(result, ISC_R_SUCCESS); + used = isc_buffer_usedlength(b); + assert_int_equal(used, 3 + 3); + + /* + * Also check the terminating NULL byte is there, even though it is not + * part of the buffer's used region. + */ + assert_memory_equal(isc_buffer_current(b), "foobar", 7); + + /* + * Skip over data from previous check to prevent failures in previous + * check from affecting this one. + */ + prev_used = used; + isc_buffer_forward(b, prev_used); + + /* + * Some standard usage checks. + */ + isc_buffer_printf(b, "%d", 42); + used = isc_buffer_usedlength(b); + assert_int_equal(used - prev_used, 2); + + isc_buffer_printf(b, "baz%1X", 42); + used = isc_buffer_usedlength(b); + assert_int_equal(used - prev_used, 2 + 5); + + isc_buffer_printf(b, "%6.1f", 42.42f); + used = isc_buffer_usedlength(b); + assert_int_equal(used - prev_used, 2 + 5 + 6); + + /* + * Also check the terminating NULL byte is there, even though it is not + * part of the buffer's used region. + */ + assert_memory_equal(isc_buffer_current(b), "42baz2A 42.4", 14); + + /* + * Check an empty format string is properly handled. + * + * Note: we don't use a string literal for the format string to + * avoid triggering [-Werror=format-zero-length]. + * Note: we have a dummy third argument as some compilers complain + * without it. + */ + prev_used = used; + empty_fmt = ""; + result = isc_buffer_printf(b, empty_fmt, ""); + assert_int_equal(result, ISC_R_SUCCESS); + used = isc_buffer_usedlength(b); + assert_int_equal(prev_used, used); + + isc_buffer_free(&b); + + /* + * Check overflow on a static buffer. + */ + isc_buffer_init(&sb, buf, sizeof(buf)); + result = isc_buffer_printf(&sb, "123456"); + assert_int_equal(result, ISC_R_SUCCESS); + used = isc_buffer_usedlength(&sb); + assert_int_equal(used, 6); + + result = isc_buffer_printf(&sb, "789"); + assert_int_equal(result, ISC_R_NOSPACE); + used = isc_buffer_usedlength(&sb); + assert_int_equal(used, 6); + + result = isc_buffer_printf(&sb, "78"); + assert_int_equal(result, ISC_R_NOSPACE); + used = isc_buffer_usedlength(&sb); + assert_int_equal(used, 6); + + result = isc_buffer_printf(&sb, "7"); + assert_int_equal(result, ISC_R_SUCCESS); + used = isc_buffer_usedlength(&sb); + assert_int_equal(used, 7); +} + +ISC_TEST_LIST_START + +ISC_TEST_ENTRY(isc_buffer_reserve) +ISC_TEST_ENTRY(isc_buffer_dynamic) +ISC_TEST_ENTRY(isc_buffer_copyregion) +ISC_TEST_ENTRY(isc_buffer_printf) + +ISC_TEST_LIST_END + +ISC_TEST_MAIN -- cgit v1.2.3