changeset
begin migration of buffer tests - relates to #342
Mon, 01 Jan 2024 16:42:37 +0100
- author
- Mike Becker <universe@uap-core.de>
- date
- Mon, 01 Jan 2024 16:42:37 +0100
- changeset 789
- 9b2f5661bebd
- parent 788
- b34ff44e6433
- child 790
- 42877968260c
begin migration of buffer tests - relates to #342
| tests/Makefile | file | annotate | diff | comparison | revisions | |
| tests/test_buffer.c | file | annotate | diff | comparison | revisions | |
| tests/test_buffer.cpp | file | annotate | diff | comparison | revisions | |
| tests/ucxtest.c | file | annotate | diff | comparison | revisions |
1.1 --- a/tests/Makefile Mon Jan 01 15:33:20 2024 +0100 1.2 +++ b/tests/Makefile Mon Jan 01 16:42:37 2024 +0100 1.3 @@ -28,8 +28,8 @@ 1.4 TEST_DIR=$(build_dir)/tests 1.5 1.6 SRC = util_allocator.c test_utils.c test_hash_key.c test_allocator.c \ 1.7 - test_compare.c \ 1.8 - test_string.c test_printf.c test_mempool.c test_hash_map.c ucxtest.c 1.9 + test_compare.c test_string.c test_buffer.c \ 1.10 + test_printf.c test_mempool.c test_hash_map.c ucxtest.c 1.11 1.12 OBJ_EXT=.o 1.13 OBJ=$(SRC:%.c=$(TEST_DIR)/%$(OBJ_EXT)) 1.14 @@ -52,6 +52,11 @@ 1.15 @echo "Compiling $<" 1.16 $(CC) -o $@ $(CFLAGS) -c $< 1.17 1.18 +$(TEST_DIR)/test_buffer$(OBJ_EXT): test_buffer.c ../src/cx/test.h \ 1.19 + ../src/cx/buffer.h ../src/cx/common.h ../src/cx/allocator.h 1.20 + @echo "Compiling $<" 1.21 + $(CC) -o $@ $(CFLAGS) -c $< 1.22 + 1.23 $(TEST_DIR)/test_compare$(OBJ_EXT): test_compare.c ../src/cx/test.h \ 1.24 ../src/cx/compare.h ../src/cx/common.h 1.25 @echo "Compiling $<"
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 2.2 +++ b/tests/test_buffer.c Mon Jan 01 16:42:37 2024 +0100 2.3 @@ -0,0 +1,418 @@ 2.4 +/* 2.5 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. 2.6 + * 2.7 + * Copyright 2023 Mike Becker, Olaf Wintermann All rights reserved. 2.8 + * 2.9 + * Redistribution and use in source and binary forms, with or without 2.10 + * modification, are permitted provided that the following conditions are met: 2.11 + * 2.12 + * 1. Redistributions of source code must retain the above copyright 2.13 + * notice, this list of conditions and the following disclaimer. 2.14 + * 2.15 + * 2. Redistributions in binary form must reproduce the above copyright 2.16 + * notice, this list of conditions and the following disclaimer in the 2.17 + * documentation and/or other materials provided with the distribution. 2.18 + * 2.19 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 2.20 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2.21 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2.22 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 2.23 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 2.24 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 2.25 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2.26 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 2.27 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 2.28 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 2.29 + * POSSIBILITY OF SUCH DAMAGE. 2.30 + */ 2.31 + 2.32 +#include "cx/test.h" 2.33 +#include "util_allocator.h" 2.34 + 2.35 +#include "cx/buffer.h" 2.36 + 2.37 +static CX_TEST_SUBROUTINE(expect_default_flush_config, CxBuffer *buf) { 2.38 + CX_TEST_ASSERT(buf->flush_blkmax == 0); 2.39 + CX_TEST_ASSERT(buf->flush_blksize == 4096); 2.40 + CX_TEST_ASSERT(buf->flush_threshold == SIZE_MAX); 2.41 + CX_TEST_ASSERT(buf->flush_func == NULL); 2.42 + CX_TEST_ASSERT(buf->flush_target == NULL); 2.43 +} 2.44 + 2.45 +CX_TEST(test_buffer_init_wrap_space) { 2.46 + CxTestingAllocator talloc; 2.47 + cx_testing_allocator_init(&talloc); 2.48 + CxAllocator *alloc = &talloc.base; 2.49 + CX_TEST_DO { 2.50 + CxBuffer buf; 2.51 + void *space = cxMalloc(alloc, 16); 2.52 + cxBufferInit(&buf, space, 16, alloc, CX_BUFFER_DEFAULT); 2.53 + CX_TEST_CALL_SUBROUTINE(expect_default_flush_config, &buf); 2.54 + CX_TEST_ASSERT(buf.space == space); 2.55 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_AUTO_EXTEND) == 0); 2.56 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_FREE_CONTENTS) == 0); 2.57 + CX_TEST_ASSERT(buf.pos == 0); 2.58 + CX_TEST_ASSERT(buf.size == 0); 2.59 + CX_TEST_ASSERT(buf.capacity == 16); 2.60 + CX_TEST_ASSERT(buf.allocator == alloc); 2.61 + cxBufferDestroy(&buf); 2.62 + CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc)); 2.63 + cxFree(alloc, space); 2.64 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.65 + } 2.66 + cx_testing_allocator_destroy(&talloc); 2.67 +} 2.68 + 2.69 +CX_TEST(test_buffer_init_wrap_space_auto_extend) { 2.70 + CxTestingAllocator talloc; 2.71 + cx_testing_allocator_init(&talloc); 2.72 + CxAllocator *alloc = &talloc.base; 2.73 + CX_TEST_DO { 2.74 + CxBuffer buf; 2.75 + void *space = cxMalloc(alloc, 16); 2.76 + cxBufferInit(&buf, space, 16, alloc, CX_BUFFER_AUTO_EXTEND); 2.77 + CX_TEST_CALL_SUBROUTINE(expect_default_flush_config, &buf); 2.78 + CX_TEST_ASSERT(buf.space == space); 2.79 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_AUTO_EXTEND) == CX_BUFFER_AUTO_EXTEND); 2.80 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_FREE_CONTENTS) == 0); 2.81 + CX_TEST_ASSERT(buf.pos == 0); 2.82 + CX_TEST_ASSERT(buf.size == 0); 2.83 + CX_TEST_ASSERT(buf.capacity == 16); 2.84 + CX_TEST_ASSERT(buf.allocator == alloc); 2.85 + cxBufferDestroy(&buf); 2.86 + CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc)); 2.87 + cxFree(alloc, space); 2.88 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.89 + } 2.90 + cx_testing_allocator_destroy(&talloc); 2.91 +} 2.92 + 2.93 +CX_TEST(test_buffer_init_wrap_space_auto_free) { 2.94 + CxTestingAllocator talloc; 2.95 + cx_testing_allocator_init(&talloc); 2.96 + CxAllocator *alloc = &talloc.base; 2.97 + CX_TEST_DO { 2.98 + CxBuffer buf; 2.99 + void *space = cxMalloc(alloc, 16); 2.100 + cxBufferInit(&buf, space, 16, alloc, CX_BUFFER_FREE_CONTENTS); 2.101 + CX_TEST_CALL_SUBROUTINE(expect_default_flush_config, &buf); 2.102 + CX_TEST_ASSERT(buf.space == space); 2.103 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_AUTO_EXTEND) == 0); 2.104 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_FREE_CONTENTS) == CX_BUFFER_FREE_CONTENTS); 2.105 + CX_TEST_ASSERT(buf.pos == 0); 2.106 + CX_TEST_ASSERT(buf.size == 0); 2.107 + CX_TEST_ASSERT(buf.capacity == 16); 2.108 + CX_TEST_ASSERT(buf.allocator == alloc); 2.109 + CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc)); 2.110 + cxBufferDestroy(&buf); 2.111 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.112 + } 2.113 + cx_testing_allocator_destroy(&talloc); 2.114 +} 2.115 + 2.116 +CX_TEST(test_buffer_init_fresh_space) { 2.117 + CxTestingAllocator talloc; 2.118 + cx_testing_allocator_init(&talloc); 2.119 + CxAllocator *alloc = &talloc.base; 2.120 + CX_TEST_DO { 2.121 + CxBuffer buf; 2.122 + cxBufferInit(&buf, NULL, 8, alloc, CX_BUFFER_DEFAULT); 2.123 + CX_TEST_CALL_SUBROUTINE(expect_default_flush_config, &buf); 2.124 + CX_TEST_ASSERT(buf.space != NULL); 2.125 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_AUTO_EXTEND) == 0); 2.126 + CX_TEST_ASSERT((buf.flags & CX_BUFFER_FREE_CONTENTS) == CX_BUFFER_FREE_CONTENTS); 2.127 + CX_TEST_ASSERT(buf.pos == 0); 2.128 + CX_TEST_ASSERT(buf.size == 0); 2.129 + CX_TEST_ASSERT(buf.capacity == 8); 2.130 + CX_TEST_ASSERT(buf.allocator == alloc); 2.131 + CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc)); // space is still allocated 2.132 + cxBufferDestroy(&buf); 2.133 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.134 + } 2.135 + cx_testing_allocator_destroy(&talloc); 2.136 +} 2.137 + 2.138 +CX_TEST(test_buffer_init_on_heap) { 2.139 + CxTestingAllocator talloc; 2.140 + cx_testing_allocator_init(&talloc); 2.141 + CxAllocator *alloc = &talloc.base; 2.142 + CX_TEST_DO { 2.143 + CxBuffer *buf; 2.144 + void *space = cxMalloc(alloc, 16); 2.145 + buf = cxBufferCreate(space, 16, alloc, CX_BUFFER_FREE_CONTENTS); 2.146 + CX_TEST_ASSERT(buf != NULL); 2.147 + CX_TEST_CALL_SUBROUTINE(expect_default_flush_config, buf); 2.148 + CX_TEST_ASSERT(buf->space == space); 2.149 + CX_TEST_ASSERT((buf->flags & CX_BUFFER_AUTO_EXTEND) == 0); 2.150 + CX_TEST_ASSERT((buf->flags & CX_BUFFER_FREE_CONTENTS) == CX_BUFFER_FREE_CONTENTS); 2.151 + CX_TEST_ASSERT(buf->pos == 0); 2.152 + CX_TEST_ASSERT(buf->size == 0); 2.153 + CX_TEST_ASSERT(buf->capacity == 16); 2.154 + CX_TEST_ASSERT(buf->allocator == alloc); 2.155 + cxBufferFree(buf); 2.156 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.157 + } 2.158 + cx_testing_allocator_destroy(&talloc); 2.159 +} 2.160 + 2.161 +CX_TEST(test_buffer_minimum_capacity_sufficient) { 2.162 + CxTestingAllocator talloc; 2.163 + cx_testing_allocator_init(&talloc); 2.164 + CxAllocator *alloc = &talloc.base; 2.165 + CX_TEST_DO { 2.166 + void *space = cxMalloc(alloc, 8); 2.167 + CxBuffer buf; 2.168 + cxBufferInit(&buf, space, 8, alloc, CX_BUFFER_FREE_CONTENTS); 2.169 + memcpy(space, "Testing", 8); 2.170 + buf.size = 8; 2.171 + cxBufferMinimumCapacity(&buf, 6); 2.172 + CX_TEST_ASSERT(buf.capacity == 8); 2.173 + CX_TEST_ASSERT(buf.size == 8); 2.174 + CX_TEST_ASSERT(memcmp(buf.space, "Testing", 8) == 0); 2.175 + cxBufferDestroy(&buf); 2.176 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.177 + } 2.178 + cx_testing_allocator_destroy(&talloc); 2.179 +} 2.180 + 2.181 +CX_TEST(test_buffer_minimum_capacity_extend) { 2.182 + CxTestingAllocator talloc; 2.183 + cx_testing_allocator_init(&talloc); 2.184 + CxAllocator *alloc = &talloc.base; 2.185 + CX_TEST_DO { 2.186 + void *space = cxMalloc(alloc, 8); 2.187 + CxBuffer buf; 2.188 + cxBufferInit(&buf, space, 8, alloc, CX_BUFFER_FREE_CONTENTS); // NO auto extend! 2.189 + memcpy(space, "Testing", 8); 2.190 + buf.size = 8; 2.191 + cxBufferMinimumCapacity(&buf, 16); 2.192 + CX_TEST_ASSERT(buf.capacity == 16); 2.193 + CX_TEST_ASSERT(buf.size == 8); 2.194 + CX_TEST_ASSERT(memcmp(buf.space, "Testing", 8) == 0); 2.195 + cxBufferDestroy(&buf); 2.196 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 2.197 + } 2.198 + cx_testing_allocator_destroy(&talloc); 2.199 +} 2.200 + 2.201 +CX_TEST(test_buffer_clear) { 2.202 + char space[16]; 2.203 + strcpy(space, "clear test"); 2.204 + CxBuffer buf; 2.205 + cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.206 + CX_TEST_DO { 2.207 + CX_TEST_ASSERT(buf.size == 0); 2.208 + // only clear the used part of the buffer 2.209 + cxBufferClear(&buf); 2.210 + CX_TEST_ASSERT(0 == memcmp(space, "clear test", 10)); 2.211 + buf.size = 5; 2.212 + buf.pos = 3; 2.213 + cxBufferClear(&buf); 2.214 + CX_TEST_ASSERT(0 == memcmp(space, "\0\0\0\0\0 test", 10)); 2.215 + CX_TEST_ASSERT(buf.size == 0); 2.216 + CX_TEST_ASSERT(buf.pos == 0); 2.217 + } 2.218 + cxBufferDestroy(&buf); 2.219 +} 2.220 + 2.221 +CX_TEST(test_buffer_reset) { 2.222 + char space[16]; 2.223 + strcpy(space, "reset test"); 2.224 + CxBuffer buf; 2.225 + cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.226 + CX_TEST_DO { 2.227 + buf.size = 5; 2.228 + buf.pos = 3; 2.229 + cxBufferReset(&buf); 2.230 + CX_TEST_ASSERT(0 == memcmp(space, "reset test", 10)); 2.231 + CX_TEST_ASSERT(buf.size == 0); 2.232 + CX_TEST_ASSERT(buf.pos == 0); 2.233 + } 2.234 + cxBufferDestroy(&buf); 2.235 +} 2.236 + 2.237 +CX_TEST(test_buffer_seek_set_zero) { 2.238 + CxBuffer buf; 2.239 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.240 + buf.size = 6; 2.241 + buf.pos = 3; 2.242 + CX_TEST_DO { 2.243 + int result = cxBufferSeek(&buf, 0, SEEK_SET); 2.244 + CX_TEST_ASSERT(result == 0); 2.245 + CX_TEST_ASSERT(buf.pos == 0); 2.246 + } 2.247 + cxBufferDestroy(&buf); 2.248 +} 2.249 + 2.250 +CX_TEST(test_buffer_seek_set_valid) { 2.251 + CxBuffer buf; 2.252 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.253 + buf.size = 6; 2.254 + buf.pos = 3; 2.255 + CX_TEST_DO { 2.256 + int result = cxBufferSeek(&buf, 5, SEEK_SET); 2.257 + CX_TEST_ASSERT(result == 0); 2.258 + CX_TEST_ASSERT(buf.pos == 5); 2.259 + } 2.260 + cxBufferDestroy(&buf); 2.261 +} 2.262 + 2.263 +CX_TEST(test_buffer_seek_set_invalid) { 2.264 + CxBuffer buf; 2.265 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.266 + buf.size = 6; 2.267 + buf.pos = 3; 2.268 + CX_TEST_DO { 2.269 + int result = cxBufferSeek(&buf, 6, SEEK_SET); 2.270 + CX_TEST_ASSERT(result != 0); 2.271 + CX_TEST_ASSERT(buf.pos == 3); 2.272 + } 2.273 + cxBufferDestroy(&buf); 2.274 +} 2.275 + 2.276 +CX_TEST(test_buffer_seek_cur_zero) { 2.277 + CxBuffer buf; 2.278 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.279 + buf.size = 6; 2.280 + buf.pos = 3; 2.281 + CX_TEST_DO { 2.282 + int result = cxBufferSeek(&buf, 0, SEEK_CUR); 2.283 + CX_TEST_ASSERT(result == 0); 2.284 + CX_TEST_ASSERT(buf.pos == 3); 2.285 + } 2.286 + cxBufferDestroy(&buf); 2.287 +} 2.288 + 2.289 +CX_TEST(test_buffer_seek_cur_valid_positive) { 2.290 + CxBuffer buf; 2.291 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.292 + buf.size = 6; 2.293 + buf.pos = 3; 2.294 + CX_TEST_DO { 2.295 + int result = cxBufferSeek(&buf, 2, SEEK_CUR); 2.296 + CX_TEST_ASSERT(result == 0); 2.297 + CX_TEST_ASSERT(buf.pos == 5); 2.298 + } 2.299 + cxBufferDestroy(&buf); 2.300 +} 2.301 + 2.302 +CX_TEST(test_buffer_seek_cur_valid_negative) { 2.303 + CxBuffer buf; 2.304 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.305 + buf.size = 6; 2.306 + buf.pos = 3; 2.307 + CX_TEST_DO { 2.308 + int result = cxBufferSeek(&buf, -3, SEEK_CUR); 2.309 + CX_TEST_ASSERT(result == 0); 2.310 + CX_TEST_ASSERT(buf.pos == 0); 2.311 + } 2.312 + cxBufferDestroy(&buf); 2.313 +} 2.314 + 2.315 +CX_TEST(test_buffer_seek_cur_invalid_positive) { 2.316 + CxBuffer buf; 2.317 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.318 + buf.size = 6; 2.319 + buf.pos = 3; 2.320 + CX_TEST_DO { 2.321 + int result = cxBufferSeek(&buf, 3, SEEK_CUR); 2.322 + CX_TEST_ASSERT(result != 0); 2.323 + CX_TEST_ASSERT(buf.pos == 3); 2.324 + } 2.325 + cxBufferDestroy(&buf); 2.326 +} 2.327 + 2.328 +CX_TEST(test_buffer_seek_cur_invalid_negative) { 2.329 + CxBuffer buf; 2.330 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.331 + buf.size = 6; 2.332 + buf.pos = 3; 2.333 + CX_TEST_DO { 2.334 + int result = cxBufferSeek(&buf, -4, SEEK_CUR); 2.335 + CX_TEST_ASSERT(result != 0); 2.336 + CX_TEST_ASSERT(buf.pos == 3); 2.337 + } 2.338 + cxBufferDestroy(&buf); 2.339 +} 2.340 + 2.341 +CX_TEST(test_buffer_seek_end_zero) { 2.342 + CxBuffer buf; 2.343 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.344 + buf.size = 6; 2.345 + buf.pos = 3; 2.346 + CX_TEST_DO { 2.347 + int result = cxBufferSeek(&buf, 0, SEEK_END); 2.348 + // the (past-the-)end position is always invalid 2.349 + CX_TEST_ASSERT(result != 0); 2.350 + CX_TEST_ASSERT(buf.pos == 3); 2.351 + } 2.352 + cxBufferDestroy(&buf); 2.353 +} 2.354 + 2.355 +CX_TEST(test_buffer_seek_end_valid) { 2.356 + CxBuffer buf; 2.357 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.358 + buf.size = 6; 2.359 + buf.pos = 3; 2.360 + CX_TEST_DO { 2.361 + int result = cxBufferSeek(&buf, -6, SEEK_END); 2.362 + CX_TEST_ASSERT(result == 0); 2.363 + CX_TEST_ASSERT(buf.pos == 0); 2.364 + } 2.365 + cxBufferDestroy(&buf); 2.366 +} 2.367 + 2.368 +CX_TEST(test_buffer_seek_end_invalid) { 2.369 + CxBuffer buf; 2.370 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.371 + buf.size = 6; 2.372 + buf.pos = 3; 2.373 + CX_TEST_DO { 2.374 + int result = cxBufferSeek(&buf, 1, SEEK_END); 2.375 + CX_TEST_ASSERT(result != 0); 2.376 + CX_TEST_ASSERT(buf.pos == 3); 2.377 + } 2.378 + cxBufferDestroy(&buf); 2.379 +} 2.380 + 2.381 +CX_TEST(test_buffer_seek_whence_invalid) { 2.382 + CxBuffer buf; 2.383 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 2.384 + buf.size = 6; 2.385 + buf.pos = 3; 2.386 + CX_TEST_DO { 2.387 + int result = cxBufferSeek(&buf, 2, 9000); 2.388 + CX_TEST_ASSERT(result != 0); 2.389 + CX_TEST_ASSERT(buf.size == 6); 2.390 + CX_TEST_ASSERT(buf.pos == 3); 2.391 + } 2.392 + cxBufferDestroy(&buf); 2.393 +} 2.394 + 2.395 +CxTestSuite *cx_test_suite_buffer(void) { 2.396 + CxTestSuite *suite = cx_test_suite_new("buffer"); 2.397 + 2.398 + cx_test_register(suite, test_buffer_init_wrap_space); 2.399 + cx_test_register(suite, test_buffer_init_wrap_space_auto_extend); 2.400 + cx_test_register(suite, test_buffer_init_wrap_space_auto_free); 2.401 + cx_test_register(suite, test_buffer_init_fresh_space); 2.402 + cx_test_register(suite, test_buffer_init_on_heap); 2.403 + cx_test_register(suite, test_buffer_minimum_capacity_sufficient); 2.404 + cx_test_register(suite, test_buffer_minimum_capacity_extend); 2.405 + cx_test_register(suite, test_buffer_clear); 2.406 + cx_test_register(suite, test_buffer_reset); 2.407 + cx_test_register(suite, test_buffer_seek_set_zero); 2.408 + cx_test_register(suite, test_buffer_seek_set_valid); 2.409 + cx_test_register(suite, test_buffer_seek_set_invalid); 2.410 + cx_test_register(suite, test_buffer_seek_cur_zero); 2.411 + cx_test_register(suite, test_buffer_seek_cur_valid_positive); 2.412 + cx_test_register(suite, test_buffer_seek_cur_valid_negative); 2.413 + cx_test_register(suite, test_buffer_seek_cur_invalid_positive); 2.414 + cx_test_register(suite, test_buffer_seek_cur_invalid_negative); 2.415 + cx_test_register(suite, test_buffer_seek_end_zero); 2.416 + cx_test_register(suite, test_buffer_seek_end_valid); 2.417 + cx_test_register(suite, test_buffer_seek_end_invalid); 2.418 + cx_test_register(suite, test_buffer_seek_whence_invalid); 2.419 + 2.420 + return suite; 2.421 +}
3.1 --- a/tests/test_buffer.cpp Mon Jan 01 15:33:20 2024 +0100 3.2 +++ b/tests/test_buffer.cpp Mon Jan 01 16:42:37 2024 +0100 3.3 @@ -34,7 +34,7 @@ 3.4 class BufferFixture : public ::testing::Test { 3.5 protected: 3.6 void SetUp() override { 3.7 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.8 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.9 buf.size = 6; 3.10 buf.pos = 3; 3.11 } 3.12 @@ -46,110 +46,11 @@ 3.13 CxBuffer buf{}; 3.14 }; 3.15 3.16 -static void expect_default_flush_config(CxBuffer *buf) { 3.17 - EXPECT_EQ(buf->flush_blkmax, 0); 3.18 - EXPECT_EQ(buf->flush_blksize, 4096); 3.19 - EXPECT_EQ(buf->flush_threshold, SIZE_MAX); 3.20 - EXPECT_EQ(buf->flush_func, nullptr); 3.21 - EXPECT_EQ(buf->flush_target, nullptr); 3.22 -} 3.23 - 3.24 -TEST(BufferInit, WrapSpace) { 3.25 - CxTestingAllocator alloc; 3.26 - CxBuffer buf; 3.27 - void *space = cxMalloc(&alloc, 16); 3.28 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_DEFAULT); 3.29 - expect_default_flush_config(&buf); 3.30 - EXPECT_EQ(buf.space, space); 3.31 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0); 3.32 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0); 3.33 - EXPECT_EQ(buf.pos, 0); 3.34 - EXPECT_EQ(buf.size, 0); 3.35 - EXPECT_EQ(buf.capacity, 16); 3.36 - EXPECT_EQ(buf.allocator, &alloc); 3.37 - cxBufferDestroy(&buf); 3.38 - EXPECT_FALSE(alloc.verify()); 3.39 - cxFree(&alloc, space); 3.40 - EXPECT_TRUE(alloc.verify()); 3.41 -} 3.42 - 3.43 -TEST(BufferInit, WrapSpaceAutoExtend) { 3.44 - CxTestingAllocator alloc; 3.45 - CxBuffer buf; 3.46 - void *space = cxMalloc(&alloc, 16); 3.47 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_AUTO_EXTEND); 3.48 - expect_default_flush_config(&buf); 3.49 - EXPECT_EQ(buf.space, space); 3.50 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, CX_BUFFER_AUTO_EXTEND); 3.51 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0); 3.52 - EXPECT_EQ(buf.pos, 0); 3.53 - EXPECT_EQ(buf.size, 0); 3.54 - EXPECT_EQ(buf.capacity, 16); 3.55 - EXPECT_EQ(buf.allocator, &alloc); 3.56 - cxBufferDestroy(&buf); 3.57 - EXPECT_FALSE(alloc.verify()); 3.58 - cxFree(&alloc, space); 3.59 - EXPECT_TRUE(alloc.verify()); 3.60 -} 3.61 - 3.62 -TEST(BufferInit, WrapSpaceAutoFree) { 3.63 - CxTestingAllocator alloc; 3.64 - CxBuffer buf; 3.65 - void *space = cxMalloc(&alloc, 16); 3.66 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_FREE_CONTENTS); 3.67 - expect_default_flush_config(&buf); 3.68 - EXPECT_EQ(buf.space, space); 3.69 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0); 3.70 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS); 3.71 - EXPECT_EQ(buf.pos, 0); 3.72 - EXPECT_EQ(buf.size, 0); 3.73 - EXPECT_EQ(buf.capacity, 16); 3.74 - EXPECT_EQ(buf.allocator, &alloc); 3.75 - EXPECT_FALSE(alloc.verify()); 3.76 - cxBufferDestroy(&buf); 3.77 - EXPECT_TRUE(alloc.verify()); 3.78 -} 3.79 - 3.80 -TEST(BufferInit, FreshSpace) { 3.81 - CxTestingAllocator alloc; 3.82 - CxBuffer buf; 3.83 - cxBufferInit(&buf, nullptr, 8, &alloc, CX_BUFFER_DEFAULT); 3.84 - expect_default_flush_config(&buf); 3.85 - EXPECT_NE(buf.space, nullptr); 3.86 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0); 3.87 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS); 3.88 - EXPECT_EQ(buf.pos, 0); 3.89 - EXPECT_EQ(buf.size, 0); 3.90 - EXPECT_EQ(buf.capacity, 8); 3.91 - EXPECT_EQ(buf.allocator, &alloc); 3.92 - EXPECT_FALSE(alloc.verify()); // space is still allocated 3.93 - cxBufferDestroy(&buf); 3.94 - EXPECT_TRUE(alloc.verify()); 3.95 -} 3.96 - 3.97 -TEST(BufferInit, OnHeap) { 3.98 - CxTestingAllocator alloc; 3.99 - CxBuffer *buf; 3.100 - void *space = cxMalloc(&alloc, 16); 3.101 - buf = cxBufferCreate(space, 16, &alloc, CX_BUFFER_FREE_CONTENTS); 3.102 - EXPECT_NE(buf, nullptr); 3.103 - expect_default_flush_config(buf); 3.104 - EXPECT_EQ(buf->space, space); 3.105 - EXPECT_EQ(buf->flags & CX_BUFFER_AUTO_EXTEND, 0); 3.106 - EXPECT_EQ(buf->flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS); 3.107 - EXPECT_EQ(buf->pos, 0); 3.108 - EXPECT_EQ(buf->size, 0); 3.109 - EXPECT_EQ(buf->capacity, 16); 3.110 - EXPECT_EQ(buf->allocator, &alloc); 3.111 - cxBufferFree(buf); 3.112 - EXPECT_TRUE(alloc.verify()); 3.113 -} 3.114 - 3.115 class BufferShiftFixture : public ::testing::Test { 3.116 protected: 3.117 void SetUp() override { 3.118 - ASSERT_TRUE(alloc.verify()); 3.119 - cxBufferInit(&buf, nullptr, 16, &alloc, CX_BUFFER_DEFAULT); 3.120 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 3.121 + cxBufferInit(&buf, NULL, 16, &alloc, CX_BUFFER_DEFAULT); 3.122 memcpy(buf.space, "test____________", 16); 3.123 buf.capacity = 8; // purposely pretend that the buffer has less capacity s.t. we can test beyond the range 3.124 buf.pos = 4; 3.125 @@ -158,7 +59,7 @@ 3.126 3.127 void TearDown() override { 3.128 cxBufferDestroy(&buf); 3.129 - EXPECT_TRUE(alloc.verify()); 3.130 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); 3.131 } 3.132 3.133 CxTestingAllocator alloc; 3.134 @@ -169,193 +70,128 @@ 3.135 }; 3.136 3.137 TEST_F(BufferShiftLeft, Zero) { 3.138 - ASSERT_EQ(buf.pos, 4); 3.139 - ASSERT_EQ(buf.size, 4); 3.140 + CX_TEST_ASSERT(buf.pos == 4); 3.141 + CX_TEST_ASSERT(buf.size == 4); 3.142 int ret = cxBufferShiftLeft(&buf, 0); 3.143 - EXPECT_EQ(ret, 0); 3.144 - EXPECT_EQ(buf.pos, 4); 3.145 - EXPECT_EQ(buf.size, 4); 3.146 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0); 3.147 + CX_TEST_ASSERT(ret == 0); 3.148 + CX_TEST_ASSERT(buf.pos == 4); 3.149 + CX_TEST_ASSERT(buf.size == 4); 3.150 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0); 3.151 } 3.152 3.153 TEST_F(BufferShiftLeft, ZeroOffsetInterface) { 3.154 - ASSERT_EQ(buf.pos, 4); 3.155 - ASSERT_EQ(buf.size, 4); 3.156 + CX_TEST_ASSERT(buf.pos == 4); 3.157 + CX_TEST_ASSERT(buf.size == 4); 3.158 int ret = cxBufferShift(&buf, -0); 3.159 - EXPECT_EQ(ret, 0); 3.160 - EXPECT_EQ(buf.pos, 4); 3.161 - EXPECT_EQ(buf.size, 4); 3.162 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0); 3.163 + CX_TEST_ASSERT(ret == 0); 3.164 + CX_TEST_ASSERT(buf.pos == 4); 3.165 + CX_TEST_ASSERT(buf.size == 4); 3.166 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0); 3.167 } 3.168 3.169 TEST_F(BufferShiftLeft, Standard) { 3.170 - ASSERT_EQ(buf.pos, 4); 3.171 - ASSERT_EQ(buf.size, 4); 3.172 + CX_TEST_ASSERT(buf.pos == 4); 3.173 + CX_TEST_ASSERT(buf.size == 4); 3.174 int ret = cxBufferShiftLeft(&buf, 2); 3.175 - EXPECT_EQ(ret, 0); 3.176 - EXPECT_EQ(buf.pos, 2); 3.177 - EXPECT_EQ(buf.size, 2); 3.178 - EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0); 3.179 + CX_TEST_ASSERT(ret == 0); 3.180 + CX_TEST_ASSERT(buf.pos == 2); 3.181 + CX_TEST_ASSERT(buf.size == 2); 3.182 + CX_TEST_ASSERT(memcmp(buf.space, "stst________", 8) == 0); 3.183 } 3.184 3.185 TEST_F(BufferShiftLeft, Overshift) { 3.186 ASSERT_LT(buf.pos, 6); 3.187 ASSERT_LT(buf.size, 6); 3.188 int ret = cxBufferShiftLeft(&buf, 6); 3.189 - EXPECT_EQ(ret, 0); 3.190 - EXPECT_EQ(buf.pos, 0); 3.191 - EXPECT_EQ(buf.size, 0); 3.192 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0); 3.193 + CX_TEST_ASSERT(ret == 0); 3.194 + CX_TEST_ASSERT(buf.pos == 0); 3.195 + CX_TEST_ASSERT(buf.size == 0); 3.196 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0); 3.197 } 3.198 3.199 TEST_F(BufferShiftLeft, OvershiftPosOnly) { 3.200 buf.pos = 2; 3.201 - ASSERT_EQ(buf.size, 4); 3.202 + CX_TEST_ASSERT(buf.size == 4); 3.203 int ret = cxBufferShiftLeft(&buf, 3); 3.204 - EXPECT_EQ(ret, 0); 3.205 - EXPECT_EQ(buf.pos, 0); 3.206 - EXPECT_EQ(buf.size, 1); 3.207 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0); 3.208 + CX_TEST_ASSERT(ret == 0); 3.209 + CX_TEST_ASSERT(buf.pos == 0); 3.210 + CX_TEST_ASSERT(buf.size == 1); 3.211 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0); 3.212 } 3.213 3.214 TEST_F(BufferShiftLeft, OffsetInterface) { 3.215 buf.pos = 3; 3.216 - ASSERT_EQ(buf.size, 4); 3.217 + CX_TEST_ASSERT(buf.size == 4); 3.218 int ret = cxBufferShift(&buf, -2); 3.219 - EXPECT_EQ(ret, 0); 3.220 - EXPECT_EQ(buf.pos, 1); 3.221 - EXPECT_EQ(buf.size, 2); 3.222 - EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0); 3.223 + CX_TEST_ASSERT(ret == 0); 3.224 + CX_TEST_ASSERT(buf.pos == 1); 3.225 + CX_TEST_ASSERT(buf.size == 2); 3.226 + CX_TEST_ASSERT(memcmp(buf.space, "stst________", 8) == 0); 3.227 } 3.228 3.229 -class BufferShiftRight : public BufferShiftFixture { 3.230 -}; 3.231 - 3.232 TEST_F(BufferShiftRight, Zero) { 3.233 - ASSERT_EQ(buf.pos, 4); 3.234 - ASSERT_EQ(buf.size, 4); 3.235 + CX_TEST_ASSERT(buf.pos == 4); 3.236 + CX_TEST_ASSERT(buf.size == 4); 3.237 int ret = cxBufferShiftRight(&buf, 0); 3.238 - EXPECT_EQ(ret, 0); 3.239 - EXPECT_EQ(buf.pos, 4); 3.240 - EXPECT_EQ(buf.size, 4); 3.241 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0); 3.242 + CX_TEST_ASSERT(ret == 0); 3.243 + CX_TEST_ASSERT(buf.pos == 4); 3.244 + CX_TEST_ASSERT(buf.size == 4); 3.245 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0); 3.246 } 3.247 3.248 TEST_F(BufferShiftRight, ZeroOffsetInterface) { 3.249 - ASSERT_EQ(buf.pos, 4); 3.250 - ASSERT_EQ(buf.size, 4); 3.251 + CX_TEST_ASSERT(buf.pos == 4); 3.252 + CX_TEST_ASSERT(buf.size == 4); 3.253 int ret = cxBufferShift(&buf, +0); 3.254 - EXPECT_EQ(ret, 0); 3.255 - EXPECT_EQ(buf.pos, 4); 3.256 - EXPECT_EQ(buf.size, 4); 3.257 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0); 3.258 + CX_TEST_ASSERT(ret == 0); 3.259 + CX_TEST_ASSERT(buf.pos == 4); 3.260 + CX_TEST_ASSERT(buf.size == 4); 3.261 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0); 3.262 } 3.263 3.264 TEST_F(BufferShiftRight, Standard) { 3.265 - ASSERT_EQ(buf.pos, 4); 3.266 - ASSERT_EQ(buf.size, 4); 3.267 + CX_TEST_ASSERT(buf.pos == 4); 3.268 + CX_TEST_ASSERT(buf.size == 4); 3.269 int ret = cxBufferShiftRight(&buf, 3); 3.270 - EXPECT_EQ(ret, 0); 3.271 - EXPECT_EQ(buf.pos, 7); 3.272 - EXPECT_EQ(buf.size, 7); 3.273 - EXPECT_TRUE(memcmp(buf.space, "testest_____", 8) == 0); 3.274 + CX_TEST_ASSERT(ret == 0); 3.275 + CX_TEST_ASSERT(buf.pos == 7); 3.276 + CX_TEST_ASSERT(buf.size == 7); 3.277 + CX_TEST_ASSERT(memcmp(buf.space, "testest_____", 8) == 0); 3.278 } 3.279 3.280 TEST_F(BufferShiftRight, OvershiftDiscard) { 3.281 - ASSERT_EQ(buf.pos, 4); 3.282 - ASSERT_EQ(buf.size, 4); 3.283 - ASSERT_EQ(buf.capacity, 8); 3.284 + CX_TEST_ASSERT(buf.pos == 4); 3.285 + CX_TEST_ASSERT(buf.size == 4); 3.286 + CX_TEST_ASSERT(buf.capacity == 8); 3.287 int ret = cxBufferShiftRight(&buf, 6); 3.288 - EXPECT_EQ(ret, 0); 3.289 - EXPECT_EQ(buf.pos, 8); 3.290 - EXPECT_EQ(buf.size, 8); 3.291 - EXPECT_EQ(buf.capacity, 8); 3.292 - EXPECT_TRUE(memcmp(buf.space, "test__te____", 8) == 0); 3.293 + CX_TEST_ASSERT(ret == 0); 3.294 + CX_TEST_ASSERT(buf.pos == 8); 3.295 + CX_TEST_ASSERT(buf.size == 8); 3.296 + CX_TEST_ASSERT(buf.capacity == 8); 3.297 + CX_TEST_ASSERT(memcmp(buf.space, "test__te____", 8) == 0); 3.298 } 3.299 3.300 TEST_F(BufferShiftRight, OvershiftExtend) { 3.301 - ASSERT_EQ(buf.pos, 4); 3.302 - ASSERT_EQ(buf.size, 4); 3.303 - ASSERT_EQ(buf.capacity, 8); 3.304 + CX_TEST_ASSERT(buf.pos == 4); 3.305 + CX_TEST_ASSERT(buf.size == 4); 3.306 + CX_TEST_ASSERT(buf.capacity == 8); 3.307 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.308 int ret = cxBufferShiftRight(&buf, 6); 3.309 - EXPECT_EQ(ret, 0); 3.310 - EXPECT_EQ(buf.pos, 10); 3.311 - EXPECT_EQ(buf.size, 10); 3.312 + CX_TEST_ASSERT(ret == 0); 3.313 + CX_TEST_ASSERT(buf.pos == 10); 3.314 + CX_TEST_ASSERT(buf.size == 10); 3.315 EXPECT_GE(buf.capacity, 10); 3.316 - EXPECT_TRUE(memcmp(buf.space, "test__test__", 8) == 0); 3.317 + CX_TEST_ASSERT(memcmp(buf.space, "test__test__", 8) == 0); 3.318 } 3.319 3.320 TEST_F(BufferShiftRight, OffsetInterface) { 3.321 buf.pos = 3; 3.322 - ASSERT_EQ(buf.size, 4); 3.323 + CX_TEST_ASSERT(buf.size == 4); 3.324 int ret = cxBufferShift(&buf, 2); 3.325 - EXPECT_EQ(ret, 0); 3.326 - EXPECT_EQ(buf.pos, 5); 3.327 - EXPECT_EQ(buf.size, 6); 3.328 - EXPECT_TRUE(memcmp(buf.space, "tetest______", 8) == 0); 3.329 -} 3.330 - 3.331 -TEST(BufferMinimumCapacity, Sufficient) { 3.332 - CxTestingAllocator alloc; 3.333 - auto space = cxMalloc(&alloc, 8); 3.334 - CxBuffer buf; 3.335 - cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS); 3.336 - memcpy(space, "Testing", 8); 3.337 - buf.size = 8; 3.338 - cxBufferMinimumCapacity(&buf, 6); 3.339 - EXPECT_EQ(buf.capacity, 8); 3.340 - EXPECT_EQ(buf.size, 8); 3.341 - EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0); 3.342 - cxBufferDestroy(&buf); 3.343 - EXPECT_TRUE(alloc.verify()); 3.344 -} 3.345 - 3.346 -TEST(BufferMinimumCapacity, Extend) { 3.347 - CxTestingAllocator alloc; 3.348 - auto space = cxMalloc(&alloc, 8); 3.349 - CxBuffer buf; 3.350 - cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS); // NO auto extend! 3.351 - memcpy(space, "Testing", 8); 3.352 - buf.size = 8; 3.353 - cxBufferMinimumCapacity(&buf, 16); 3.354 - EXPECT_EQ(buf.capacity, 16); 3.355 - EXPECT_EQ(buf.size, 8); 3.356 - EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0); 3.357 - cxBufferDestroy(&buf); 3.358 - EXPECT_TRUE(alloc.verify()); 3.359 -} 3.360 - 3.361 -TEST(BufferClear, Test) { 3.362 - char space[16]; 3.363 - strcpy(space, "clear test"); 3.364 - CxBuffer buf; 3.365 - cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.366 - ASSERT_EQ(buf.size, 0); 3.367 - // only clear the used part of the buffer 3.368 - cxBufferClear(&buf); 3.369 - EXPECT_EQ(memcmp(space, "clear test", 10), 0); 3.370 - buf.size = 5; 3.371 - buf.pos = 3; 3.372 - cxBufferClear(&buf); 3.373 - EXPECT_EQ(memcmp(space, "\0\0\0\0\0 test", 10), 0); 3.374 - EXPECT_EQ(buf.size, 0); 3.375 - EXPECT_EQ(buf.pos, 0); 3.376 - cxBufferDestroy(&buf); 3.377 -} 3.378 - 3.379 -TEST(BufferReset, Test) { 3.380 - char space[16]; 3.381 - strcpy(space, "reset test"); 3.382 - CxBuffer buf; 3.383 - cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.384 - buf.size = 5; 3.385 - buf.pos = 3; 3.386 - cxBufferReset(&buf); 3.387 - EXPECT_EQ(memcmp(space, "reset test", 10), 0); 3.388 - EXPECT_EQ(buf.size, 0); 3.389 - EXPECT_EQ(buf.pos, 0); 3.390 - cxBufferDestroy(&buf); 3.391 + CX_TEST_ASSERT(ret == 0); 3.392 + CX_TEST_ASSERT(buf.pos == 5); 3.393 + CX_TEST_ASSERT(buf.size == 6); 3.394 + CX_TEST_ASSERT(memcmp(buf.space, "tetest______", 8) == 0); 3.395 } 3.396 3.397 class BufferWrite : public ::testing::Test { 3.398 @@ -363,8 +199,8 @@ 3.399 CxBuffer buf{}, target{}; 3.400 3.401 void SetUp() override { 3.402 - cxBufferInit(&target, nullptr, 16, cxDefaultAllocator, CX_BUFFER_AUTO_EXTEND); 3.403 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.404 + cxBufferInit(&target, NULL, 16, cxDefaultAllocator, CX_BUFFER_AUTO_EXTEND); 3.405 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.406 buf.capacity = 8; // artificially reduce capacity to check OOB writes 3.407 memset(buf.space, 0, 16); 3.408 memcpy(buf.space, "prep", 4); 3.409 @@ -402,221 +238,221 @@ 3.410 3.411 TEST_F(BufferWrite, SizeOneFit) { 3.412 const char *data = "test"; 3.413 - ASSERT_EQ(buf.capacity, 8); 3.414 - ASSERT_EQ(buf.pos, 4); 3.415 - ASSERT_EQ(buf.size, 4); 3.416 + CX_TEST_ASSERT(buf.capacity == 8); 3.417 + CX_TEST_ASSERT(buf.pos == 4); 3.418 + CX_TEST_ASSERT(buf.size == 4); 3.419 size_t written = cxBufferWrite(data, 1, 4, &buf); 3.420 - EXPECT_EQ(written, 4); 3.421 - EXPECT_EQ(buf.size, 8); 3.422 - EXPECT_EQ(buf.pos, 8); 3.423 - EXPECT_EQ(buf.capacity, 8); 3.424 + CX_TEST_ASSERT(written == 4); 3.425 + CX_TEST_ASSERT(buf.size == 8); 3.426 + CX_TEST_ASSERT(buf.pos == 8); 3.427 + CX_TEST_ASSERT(buf.capacity == 8); 3.428 EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0); 3.429 } 3.430 3.431 TEST_F(BufferWrite, SizeOneDiscard) { 3.432 const char *data = "testing"; 3.433 - ASSERT_EQ(buf.capacity, 8); 3.434 - ASSERT_EQ(buf.pos, 4); 3.435 - ASSERT_EQ(buf.size, 4); 3.436 + CX_TEST_ASSERT(buf.capacity == 8); 3.437 + CX_TEST_ASSERT(buf.pos == 4); 3.438 + CX_TEST_ASSERT(buf.size == 4); 3.439 size_t written = cxBufferWrite(data, 1, 7, &buf); 3.440 - EXPECT_EQ(written, 4); 3.441 - EXPECT_EQ(buf.size, 8); 3.442 - EXPECT_EQ(buf.pos, 8); 3.443 - EXPECT_EQ(buf.capacity, 8); 3.444 + CX_TEST_ASSERT(written == 4); 3.445 + CX_TEST_ASSERT(buf.size == 8); 3.446 + CX_TEST_ASSERT(buf.pos == 8); 3.447 + CX_TEST_ASSERT(buf.capacity == 8); 3.448 EXPECT_EQ(memcmp(buf.space, "preptest\0", 9), 0); 3.449 } 3.450 3.451 TEST_F(BufferWrite, SizeOneExtend) { 3.452 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.453 const char *data = "testing"; 3.454 - ASSERT_EQ(buf.capacity, 8); 3.455 - ASSERT_EQ(buf.pos, 4); 3.456 - ASSERT_EQ(buf.size, 4); 3.457 + CX_TEST_ASSERT(buf.capacity == 8); 3.458 + CX_TEST_ASSERT(buf.pos == 4); 3.459 + CX_TEST_ASSERT(buf.size == 4); 3.460 size_t written = cxBufferWrite(data, 1, 7, &buf); 3.461 - EXPECT_EQ(written, 7); 3.462 - EXPECT_EQ(buf.size, 11); 3.463 - EXPECT_EQ(buf.pos, 11); 3.464 + CX_TEST_ASSERT(written == 7); 3.465 + CX_TEST_ASSERT(buf.size == 11); 3.466 + CX_TEST_ASSERT(buf.pos == 11); 3.467 EXPECT_GE(buf.capacity, 11); 3.468 EXPECT_EQ(memcmp(buf.space, "preptesting", 11), 0); 3.469 } 3.470 3.471 TEST_F(BufferWrite, MultibyteFit) { 3.472 const char *data = "test"; 3.473 - ASSERT_EQ(buf.capacity, 8); 3.474 - ASSERT_EQ(buf.pos, 4); 3.475 - ASSERT_EQ(buf.size, 4); 3.476 + CX_TEST_ASSERT(buf.capacity == 8); 3.477 + CX_TEST_ASSERT(buf.pos == 4); 3.478 + CX_TEST_ASSERT(buf.size == 4); 3.479 size_t written = cxBufferWrite(data, 2, 2, &buf); 3.480 - EXPECT_EQ(written, 2); 3.481 - EXPECT_EQ(buf.size, 8); 3.482 - EXPECT_EQ(buf.pos, 8); 3.483 - EXPECT_EQ(buf.capacity, 8); 3.484 + CX_TEST_ASSERT(written == 2); 3.485 + CX_TEST_ASSERT(buf.size == 8); 3.486 + CX_TEST_ASSERT(buf.pos == 8); 3.487 + CX_TEST_ASSERT(buf.capacity == 8); 3.488 EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0); 3.489 } 3.490 3.491 TEST_F(BufferWrite, MultibyteDiscard) { 3.492 const char *data = "testing"; 3.493 - ASSERT_EQ(buf.capacity, 8); 3.494 - ASSERT_EQ(buf.size, 4); 3.495 + CX_TEST_ASSERT(buf.capacity == 8); 3.496 + CX_TEST_ASSERT(buf.size == 4); 3.497 buf.pos = 3; 3.498 size_t written = cxBufferWrite(data, 2, 4, &buf); 3.499 // remember: whole elements are discarded if they do not fit 3.500 - EXPECT_EQ(written, 2); 3.501 - EXPECT_EQ(buf.size, 7); 3.502 - EXPECT_EQ(buf.pos, 7); 3.503 - EXPECT_EQ(buf.capacity, 8); 3.504 + CX_TEST_ASSERT(written == 2); 3.505 + CX_TEST_ASSERT(buf.size == 7); 3.506 + CX_TEST_ASSERT(buf.pos == 7); 3.507 + CX_TEST_ASSERT(buf.capacity == 8); 3.508 EXPECT_EQ(memcmp(buf.space, "pretest\0", 8), 0); 3.509 } 3.510 3.511 TEST_F(BufferWrite, MultibyteExtend) { 3.512 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.513 const char *data = "tester"; 3.514 - ASSERT_EQ(buf.capacity, 8); 3.515 - ASSERT_EQ(buf.size, 4); 3.516 + CX_TEST_ASSERT(buf.capacity == 8); 3.517 + CX_TEST_ASSERT(buf.size == 4); 3.518 buf.pos = 3; 3.519 size_t written = cxBufferWrite(data, 2, 3, &buf); 3.520 // remember: whole elements are discarded if they do not fit 3.521 - EXPECT_EQ(written, 3); 3.522 - EXPECT_EQ(buf.size, 9); 3.523 - EXPECT_EQ(buf.pos, 9); 3.524 + CX_TEST_ASSERT(written == 3); 3.525 + CX_TEST_ASSERT(buf.size == 9); 3.526 + CX_TEST_ASSERT(buf.pos == 9); 3.527 EXPECT_GE(buf.capacity, 9); 3.528 EXPECT_EQ(memcmp(buf.space, "pretester", 9), 0); 3.529 } 3.530 3.531 TEST_F(BufferWrite, PutcWrapperFit) { 3.532 - ASSERT_EQ(buf.capacity, 8); 3.533 - ASSERT_EQ(buf.pos, 4); 3.534 - ASSERT_EQ(buf.size, 4); 3.535 + CX_TEST_ASSERT(buf.capacity == 8); 3.536 + CX_TEST_ASSERT(buf.pos == 4); 3.537 + CX_TEST_ASSERT(buf.size == 4); 3.538 int c = cxBufferPut(&buf, 0x200 | 'a'); 3.539 - EXPECT_EQ(c, 'a'); 3.540 - EXPECT_EQ(buf.size, 5); 3.541 - EXPECT_EQ(buf.pos, 5); 3.542 - EXPECT_EQ(buf.capacity, 8); 3.543 + CX_TEST_ASSERT(c == 'a'); 3.544 + CX_TEST_ASSERT(buf.size == 5); 3.545 + CX_TEST_ASSERT(buf.pos == 5); 3.546 + CX_TEST_ASSERT(buf.capacity == 8); 3.547 EXPECT_EQ(memcmp(buf.space, "prepa\0", 6), 0); 3.548 } 3.549 3.550 TEST_F(BufferWrite, PutcWrapperDiscard) { 3.551 - ASSERT_EQ(buf.capacity, 8); 3.552 - ASSERT_EQ(buf.size, 4); 3.553 + CX_TEST_ASSERT(buf.capacity == 8); 3.554 + CX_TEST_ASSERT(buf.size == 4); 3.555 buf.pos = 8; 3.556 int c = cxBufferPut(&buf, 0x200 | 'a'); 3.557 - EXPECT_EQ(c, EOF); 3.558 - EXPECT_EQ(buf.size, 4); 3.559 - EXPECT_EQ(buf.pos, 8); 3.560 - EXPECT_EQ(buf.capacity, 8); 3.561 + CX_TEST_ASSERT(c == EOF); 3.562 + CX_TEST_ASSERT(buf.size == 4); 3.563 + CX_TEST_ASSERT(buf.pos == 8); 3.564 + CX_TEST_ASSERT(buf.capacity == 8); 3.565 EXPECT_EQ(memcmp(buf.space, "prep\0\0\0\0\0", 9), 0); 3.566 } 3.567 3.568 TEST_F(BufferWrite, PutcWrapperExtend) { 3.569 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.570 - ASSERT_EQ(buf.capacity, 8); 3.571 - ASSERT_EQ(buf.size, 4); 3.572 + CX_TEST_ASSERT(buf.capacity == 8); 3.573 + CX_TEST_ASSERT(buf.size == 4); 3.574 buf.pos = 8; 3.575 int c = cxBufferPut(&buf, 0x200 | 'a'); 3.576 - EXPECT_EQ(c, 'a'); 3.577 - EXPECT_EQ(buf.size, 9); 3.578 - EXPECT_EQ(buf.pos, 9); 3.579 + CX_TEST_ASSERT(c == 'a'); 3.580 + CX_TEST_ASSERT(buf.size == 9); 3.581 + CX_TEST_ASSERT(buf.pos == 9); 3.582 EXPECT_GE(buf.capacity, 9); 3.583 EXPECT_EQ(memcmp(buf.space, "prep\0\0\0\0a", 9), 0); 3.584 } 3.585 3.586 TEST_F(BufferWrite, PutStringWrapperFit) { 3.587 const char *data = "test"; 3.588 - ASSERT_EQ(buf.capacity, 8); 3.589 - ASSERT_EQ(buf.pos, 4); 3.590 - ASSERT_EQ(buf.size, 4); 3.591 + CX_TEST_ASSERT(buf.capacity == 8); 3.592 + CX_TEST_ASSERT(buf.pos == 4); 3.593 + CX_TEST_ASSERT(buf.size == 4); 3.594 size_t written = cxBufferPutString(&buf, data); 3.595 - EXPECT_EQ(written, 4); 3.596 - EXPECT_EQ(buf.size, 8); 3.597 - EXPECT_EQ(buf.pos, 8); 3.598 - EXPECT_EQ(buf.capacity, 8); 3.599 + CX_TEST_ASSERT(written == 4); 3.600 + CX_TEST_ASSERT(buf.size == 8); 3.601 + CX_TEST_ASSERT(buf.pos == 8); 3.602 + CX_TEST_ASSERT(buf.capacity == 8); 3.603 EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0); 3.604 } 3.605 3.606 TEST_F(BufferWrite, PutStringWrapperDiscard) { 3.607 const char *data = "testing"; 3.608 - ASSERT_EQ(buf.capacity, 8); 3.609 - ASSERT_EQ(buf.pos, 4); 3.610 - ASSERT_EQ(buf.size, 4); 3.611 + CX_TEST_ASSERT(buf.capacity == 8); 3.612 + CX_TEST_ASSERT(buf.pos == 4); 3.613 + CX_TEST_ASSERT(buf.size == 4); 3.614 size_t written = cxBufferPutString(&buf, data); 3.615 - EXPECT_EQ(written, 4); 3.616 - EXPECT_EQ(buf.size, 8); 3.617 - EXPECT_EQ(buf.pos, 8); 3.618 - EXPECT_EQ(buf.capacity, 8); 3.619 + CX_TEST_ASSERT(written == 4); 3.620 + CX_TEST_ASSERT(buf.size == 8); 3.621 + CX_TEST_ASSERT(buf.pos == 8); 3.622 + CX_TEST_ASSERT(buf.capacity == 8); 3.623 EXPECT_EQ(memcmp(buf.space, "preptest\0", 9), 0); 3.624 } 3.625 3.626 TEST_F(BufferWrite, PutStringWrapperExtend) { 3.627 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.628 const char *data = "testing"; 3.629 - ASSERT_EQ(buf.capacity, 8); 3.630 - ASSERT_EQ(buf.pos, 4); 3.631 - ASSERT_EQ(buf.size, 4); 3.632 + CX_TEST_ASSERT(buf.capacity == 8); 3.633 + CX_TEST_ASSERT(buf.pos == 4); 3.634 + CX_TEST_ASSERT(buf.size == 4); 3.635 size_t written = cxBufferPutString(&buf, data); 3.636 - EXPECT_EQ(written, 7); 3.637 - EXPECT_EQ(buf.size, 11); 3.638 - EXPECT_EQ(buf.pos, 11); 3.639 + CX_TEST_ASSERT(written == 7); 3.640 + CX_TEST_ASSERT(buf.size == 11); 3.641 + CX_TEST_ASSERT(buf.pos == 11); 3.642 EXPECT_GE(buf.capacity, 11); 3.643 EXPECT_EQ(memcmp(buf.space, "preptesting", 11), 0); 3.644 } 3.645 3.646 TEST_F(BufferWrite, MultOverflow) { 3.647 const char *data = "testing"; 3.648 - ASSERT_EQ(buf.capacity, 8); 3.649 - ASSERT_EQ(buf.pos, 4); 3.650 - ASSERT_EQ(buf.size, 4); 3.651 + CX_TEST_ASSERT(buf.capacity == 8); 3.652 + CX_TEST_ASSERT(buf.pos == 4); 3.653 + CX_TEST_ASSERT(buf.size == 4); 3.654 size_t written = cxBufferWrite(data, 8, SIZE_MAX / 4, &buf); 3.655 - EXPECT_EQ(written, 0); 3.656 - EXPECT_EQ(buf.capacity, 8); 3.657 - EXPECT_EQ(buf.pos, 4); 3.658 - EXPECT_EQ(buf.size, 4); 3.659 + CX_TEST_ASSERT(written == 0); 3.660 + CX_TEST_ASSERT(buf.capacity == 8); 3.661 + CX_TEST_ASSERT(buf.pos == 4); 3.662 + CX_TEST_ASSERT(buf.size == 4); 3.663 EXPECT_EQ(memcmp(buf.space, "prep\0", 5), 0); 3.664 } 3.665 3.666 TEST_F(BufferWrite, MaxCapaOverflow) { 3.667 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.668 const char *data = "testing"; 3.669 - ASSERT_EQ(buf.capacity, 8); 3.670 - ASSERT_EQ(buf.pos, 4); 3.671 - ASSERT_EQ(buf.size, 4); 3.672 + CX_TEST_ASSERT(buf.capacity == 8); 3.673 + CX_TEST_ASSERT(buf.pos == 4); 3.674 + CX_TEST_ASSERT(buf.size == 4); 3.675 size_t written = cxBufferWrite(data, 1, SIZE_MAX - 2, &buf); 3.676 - EXPECT_EQ(written, 0); 3.677 - EXPECT_EQ(buf.capacity, 8); 3.678 - EXPECT_EQ(buf.pos, 4); 3.679 - EXPECT_EQ(buf.size, 4); 3.680 + CX_TEST_ASSERT(written == 0); 3.681 + CX_TEST_ASSERT(buf.capacity == 8); 3.682 + CX_TEST_ASSERT(buf.pos == 4); 3.683 + CX_TEST_ASSERT(buf.size == 4); 3.684 EXPECT_EQ(memcmp(buf.space, "prep\0", 5), 0); 3.685 } 3.686 3.687 TEST_F(BufferWrite, OnlyOverwrite) { 3.688 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.689 - ASSERT_EQ(buf.capacity, 8); 3.690 + CX_TEST_ASSERT(buf.capacity == 8); 3.691 memcpy(buf.space, "preptest", 8); 3.692 buf.pos = 3; 3.693 buf.size = 8; 3.694 size_t written = cxBufferWrite("XXX", 2, 2, &buf); 3.695 - EXPECT_EQ(written, 2); 3.696 - EXPECT_EQ(buf.capacity, 8); 3.697 - EXPECT_EQ(buf.size, 8); 3.698 - EXPECT_EQ(buf.pos, 7); 3.699 + CX_TEST_ASSERT(written == 2); 3.700 + CX_TEST_ASSERT(buf.capacity == 8); 3.701 + CX_TEST_ASSERT(buf.size == 8); 3.702 + CX_TEST_ASSERT(buf.pos == 7); 3.703 EXPECT_EQ(memcmp(buf.space, "preXXX\0t", 8), 0); 3.704 } 3.705 3.706 TEST_F(BufferWrite, FlushAtCapacity) { 3.707 enableFlushing(); 3.708 - ASSERT_EQ(buf.capacity, 8); 3.709 - ASSERT_EQ(buf.pos, 4); 3.710 + CX_TEST_ASSERT(buf.capacity == 8); 3.711 + CX_TEST_ASSERT(buf.pos == 4); 3.712 size_t written = cxBufferWrite("foo", 1, 3, &buf); 3.713 - EXPECT_EQ(written, 3); 3.714 - ASSERT_EQ(buf.pos, 7); 3.715 - ASSERT_EQ(buf.size, 7); 3.716 - ASSERT_EQ(target.pos, 0); 3.717 - ASSERT_EQ(target.size, 0); 3.718 + CX_TEST_ASSERT(written == 3); 3.719 + CX_TEST_ASSERT(buf.pos == 7); 3.720 + CX_TEST_ASSERT(buf.size == 7); 3.721 + CX_TEST_ASSERT(target.pos == 0); 3.722 + CX_TEST_ASSERT(target.size == 0); 3.723 written = cxBufferWrite("hello", 1, 5, &buf); 3.724 - EXPECT_EQ(written, 5); 3.725 - EXPECT_EQ(buf.pos, 0); 3.726 - EXPECT_EQ(buf.size, 0); 3.727 - EXPECT_EQ(buf.capacity, 8); 3.728 - EXPECT_EQ(target.pos, 12); 3.729 - ASSERT_EQ(target.size, 12); 3.730 + CX_TEST_ASSERT(written == 5); 3.731 + CX_TEST_ASSERT(buf.pos == 0); 3.732 + CX_TEST_ASSERT(buf.size == 0); 3.733 + CX_TEST_ASSERT(buf.capacity == 8); 3.734 + CX_TEST_ASSERT(target.pos == 12); 3.735 + CX_TEST_ASSERT(target.size == 12); 3.736 EXPECT_EQ(memcmp(target.space, "prepfoohello", 12), 0); 3.737 } 3.738 3.739 @@ -624,23 +460,23 @@ 3.740 enableFlushing(); 3.741 buf.flush_threshold = 12; 3.742 buf.flags |= CX_BUFFER_AUTO_EXTEND; 3.743 - ASSERT_EQ(buf.capacity, 8); 3.744 - ASSERT_EQ(buf.pos, 4); 3.745 + CX_TEST_ASSERT(buf.capacity == 8); 3.746 + CX_TEST_ASSERT(buf.pos == 4); 3.747 size_t written = cxBufferWrite("foobar", 1, 6, &buf); 3.748 - EXPECT_EQ(written, 6); 3.749 - ASSERT_EQ(buf.pos, 10); 3.750 - ASSERT_EQ(buf.size, 10); 3.751 + CX_TEST_ASSERT(written == 6); 3.752 + CX_TEST_ASSERT(buf.pos == 10); 3.753 + CX_TEST_ASSERT(buf.size == 10); 3.754 ASSERT_GE(buf.capacity, 10); 3.755 ASSERT_LE(buf.capacity, 12); 3.756 - ASSERT_EQ(target.pos, 0); 3.757 - ASSERT_EQ(target.size, 0); 3.758 + CX_TEST_ASSERT(target.pos == 0); 3.759 + CX_TEST_ASSERT(target.size == 0); 3.760 written = cxBufferWrite("hello", 1, 5, &buf); 3.761 - EXPECT_EQ(written, 5); 3.762 - EXPECT_EQ(buf.pos, 0); 3.763 - EXPECT_EQ(buf.size, 0); 3.764 + CX_TEST_ASSERT(written == 5); 3.765 + CX_TEST_ASSERT(buf.pos == 0); 3.766 + CX_TEST_ASSERT(buf.size == 0); 3.767 EXPECT_LE(buf.capacity, 12); 3.768 - EXPECT_EQ(target.pos, 15); 3.769 - ASSERT_EQ(target.size, 15); 3.770 + CX_TEST_ASSERT(target.pos == 15); 3.771 + CX_TEST_ASSERT(target.size == 15); 3.772 EXPECT_EQ(memcmp(target.space, "prepfoobarhello", 15), 0); 3.773 } 3.774 3.775 @@ -650,133 +486,43 @@ 3.776 target.capacity = 16; 3.777 target.flags &= ~CX_BUFFER_AUTO_EXTEND; 3.778 buf.flush_func = (cx_write_func) mock_write_limited_rate; 3.779 - ASSERT_EQ(buf.capacity, 8); 3.780 - ASSERT_EQ(buf.pos, 4); 3.781 + CX_TEST_ASSERT(buf.capacity == 8); 3.782 + CX_TEST_ASSERT(buf.pos == 4); 3.783 size_t written = cxBufferWrite("foo", 1, 3, &buf); 3.784 - EXPECT_EQ(written, 3); 3.785 - ASSERT_EQ(buf.pos, 7); 3.786 - ASSERT_EQ(buf.size, 7); 3.787 - ASSERT_EQ(target.pos, 0); 3.788 - ASSERT_EQ(target.size, 0); 3.789 + CX_TEST_ASSERT(written == 3); 3.790 + CX_TEST_ASSERT(buf.pos == 7); 3.791 + CX_TEST_ASSERT(buf.size == 7); 3.792 + CX_TEST_ASSERT(target.pos == 0); 3.793 + CX_TEST_ASSERT(target.size == 0); 3.794 written = cxBufferWrite("hello, world!", 1, 13, &buf); 3.795 // " world!" fits into this buffer, the remaining stuff is flushed out 3.796 - EXPECT_EQ(written, 13); 3.797 - EXPECT_EQ(buf.pos, 7); 3.798 - EXPECT_EQ(buf.size, 7); 3.799 - EXPECT_EQ(buf.capacity, 8); 3.800 + CX_TEST_ASSERT(written == 13); 3.801 + CX_TEST_ASSERT(buf.pos == 7); 3.802 + CX_TEST_ASSERT(buf.size == 7); 3.803 + CX_TEST_ASSERT(buf.capacity == 8); 3.804 EXPECT_EQ(memcmp(buf.space, " world!", 7), 0); 3.805 - EXPECT_EQ(target.pos, 13); 3.806 - ASSERT_EQ(target.size, 13); 3.807 - EXPECT_EQ(target.capacity, 16); 3.808 + CX_TEST_ASSERT(target.pos == 13); 3.809 + CX_TEST_ASSERT(target.size == 13); 3.810 + CX_TEST_ASSERT(target.capacity == 16); 3.811 EXPECT_EQ(memcmp(target.space, "prepfoohello,", 13), 0); 3.812 } 3.813 3.814 -class BufferSeek : public BufferFixture { 3.815 -}; 3.816 - 3.817 -TEST_F(BufferSeek, SetZero) { 3.818 - int result = cxBufferSeek(&buf, 0, SEEK_SET); 3.819 - EXPECT_EQ(result, 0); 3.820 - EXPECT_EQ(buf.pos, 0); 3.821 -} 3.822 - 3.823 -TEST_F(BufferSeek, SetValid) { 3.824 - int result = cxBufferSeek(&buf, 5, SEEK_SET); 3.825 - EXPECT_EQ(result, 0); 3.826 - EXPECT_EQ(buf.pos, 5); 3.827 -} 3.828 - 3.829 -TEST_F(BufferSeek, SetInvalid) { 3.830 - ASSERT_EQ(buf.pos, 3); 3.831 - int result = cxBufferSeek(&buf, 6, SEEK_SET); 3.832 - EXPECT_NE(result, 0); 3.833 - EXPECT_EQ(buf.pos, 3); 3.834 -} 3.835 - 3.836 -TEST_F(BufferSeek, CurZero) { 3.837 - ASSERT_EQ(buf.pos, 3); 3.838 - int result = cxBufferSeek(&buf, 0, SEEK_CUR); 3.839 - EXPECT_EQ(result, 0); 3.840 - EXPECT_EQ(buf.pos, 3); 3.841 -} 3.842 - 3.843 -TEST_F(BufferSeek, CurValidPositive) { 3.844 - ASSERT_EQ(buf.pos, 3); 3.845 - int result = cxBufferSeek(&buf, 2, SEEK_CUR); 3.846 - EXPECT_EQ(result, 0); 3.847 - EXPECT_EQ(buf.pos, 5); 3.848 -} 3.849 - 3.850 -TEST_F(BufferSeek, CurValidNegative) { 3.851 - ASSERT_EQ(buf.pos, 3); 3.852 - int result = cxBufferSeek(&buf, -3, SEEK_CUR); 3.853 - EXPECT_EQ(result, 0); 3.854 - EXPECT_EQ(buf.pos, 0); 3.855 -} 3.856 - 3.857 -TEST_F(BufferSeek, CurInvalidPositive) { 3.858 - ASSERT_EQ(buf.pos, 3); 3.859 - int result = cxBufferSeek(&buf, 3, SEEK_CUR); 3.860 - EXPECT_NE(result, 0); 3.861 - EXPECT_EQ(buf.pos, 3); 3.862 -} 3.863 - 3.864 -TEST_F(BufferSeek, CurInvalidNegative) { 3.865 - ASSERT_EQ(buf.pos, 3); 3.866 - int result = cxBufferSeek(&buf, -4, SEEK_CUR); 3.867 - EXPECT_NE(result, 0); 3.868 - EXPECT_EQ(buf.pos, 3); 3.869 -} 3.870 - 3.871 -TEST_F(BufferSeek, EndZero) { 3.872 - ASSERT_EQ(buf.size, 6); 3.873 - int result = cxBufferSeek(&buf, 0, SEEK_END); 3.874 - // the (past-the-)end position is always invalid 3.875 - EXPECT_NE(result, 0); 3.876 - EXPECT_EQ(buf.pos, 3); 3.877 -} 3.878 - 3.879 -TEST_F(BufferSeek, EndValid) { 3.880 - ASSERT_EQ(buf.size, 6); 3.881 - int result = cxBufferSeek(&buf, -6, SEEK_END); 3.882 - EXPECT_EQ(result, 0); 3.883 - EXPECT_EQ(buf.pos, 0); 3.884 -} 3.885 - 3.886 -TEST_F(BufferSeek, EndInvalid) { 3.887 - ASSERT_EQ(buf.size, 6); 3.888 - int result = cxBufferSeek(&buf, 1, SEEK_END); 3.889 - EXPECT_NE(result, 0); 3.890 - EXPECT_EQ(buf.pos, 3); 3.891 -} 3.892 - 3.893 -TEST_F(BufferSeek, WhenceInvalid) { 3.894 - ASSERT_EQ(buf.size, 6); 3.895 - ASSERT_EQ(buf.pos, 3); 3.896 - int result = cxBufferSeek(&buf, 2, 9000); 3.897 - EXPECT_NE(result, 0); 3.898 - EXPECT_EQ(buf.size, 6); 3.899 - EXPECT_EQ(buf.pos, 3); 3.900 -} 3.901 - 3.902 -class BufferEof : public BufferFixture { 3.903 -}; 3.904 3.905 TEST_F(BufferEof, Reached) { 3.906 buf.pos = buf.size; 3.907 - EXPECT_TRUE(cxBufferEof(&buf)); 3.908 + CX_TEST_ASSERT(cxBufferEof(&buf)); 3.909 buf.pos = buf.size - 1; 3.910 - ASSERT_FALSE(cxBufferEof(&buf)); 3.911 + CX_TEST_ASSERT(!cxBufferEof(&buf)); 3.912 cxBufferPut(&buf, 'a'); 3.913 - EXPECT_TRUE(cxBufferEof(&buf)); 3.914 + CX_TEST_ASSERT(cxBufferEof(&buf)); 3.915 } 3.916 3.917 TEST_F(BufferEof, NotReached) { 3.918 buf.pos = buf.size - 1; 3.919 - EXPECT_FALSE(cxBufferEof(&buf)); 3.920 + CX_TEST_ASSERT(!cxBufferEof(&buf)); 3.921 buf.pos = 0; 3.922 cxBufferWrite("test", 1, 5, &buf); 3.923 - EXPECT_FALSE(cxBufferEof(&buf)); 3.924 + CX_TEST_ASSERT(!cxBufferEof(&buf)); 3.925 } 3.926 3.927 class BufferRead : public ::testing::Test { 3.928 @@ -784,7 +530,7 @@ 3.929 CxBuffer buf{}; 3.930 3.931 void SetUp() override { 3.932 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.933 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT); 3.934 buf.capacity = 8; // artificially reduce capacity to check OOB writes 3.935 memset(buf.space, 0, 16); 3.936 memcpy(buf.space, "some data", 9); 3.937 @@ -802,7 +548,7 @@ 3.938 EXPECT_EQ(cxBufferGet(&buf), 'e'); 3.939 EXPECT_EQ(cxBufferGet(&buf), ' '); 3.940 EXPECT_EQ(cxBufferGet(&buf), 'd'); 3.941 - EXPECT_EQ(buf.pos, 6); 3.942 + CX_TEST_ASSERT(buf.pos == 6); 3.943 } 3.944 3.945 TEST_F(BufferRead, GetEof) { 3.946 @@ -814,18 +560,18 @@ 3.947 buf.pos = 2; 3.948 char target[4]; 3.949 auto read = cxBufferRead(&target, 1, 4, &buf); 3.950 - ASSERT_EQ(read, 4); 3.951 + CX_TEST_ASSERT(read == 4); 3.952 EXPECT_EQ(memcmp(&target, "me d", 4), 0); 3.953 - EXPECT_EQ(buf.pos, 6); 3.954 + CX_TEST_ASSERT(buf.pos == 6); 3.955 } 3.956 3.957 TEST_F(BufferRead, ReadOutOfBounds) { 3.958 buf.pos = 6; 3.959 char target[4]; 3.960 auto read = cxBufferRead(&target, 1, 4, &buf); 3.961 - ASSERT_EQ(read, 3); 3.962 + CX_TEST_ASSERT(read == 3); 3.963 EXPECT_EQ(memcmp(&target, "ata", 3), 0); 3.964 - EXPECT_EQ(buf.pos, 9); 3.965 + CX_TEST_ASSERT(buf.pos == 9); 3.966 } 3.967 3.968 TEST_F(BufferRead, ReadOutOfBoundsMultibyte) { 3.969 @@ -833,15 +579,15 @@ 3.970 char target[4]; 3.971 target[2] = '\0'; 3.972 auto read = cxBufferRead(&target, 2, 2, &buf); 3.973 - ASSERT_EQ(read, 1); 3.974 + CX_TEST_ASSERT(read == 1); 3.975 EXPECT_EQ(memcmp(&target, "at\0", 3), 0); 3.976 - EXPECT_EQ(buf.pos, 8); 3.977 + CX_TEST_ASSERT(buf.pos == 8); 3.978 } 3.979 3.980 TEST_F(BufferRead, ReadEof) { 3.981 buf.pos = 9; 3.982 char target[4]; 3.983 auto read = cxBufferRead(&target, 1, 1, &buf); 3.984 - ASSERT_EQ(read, 0); 3.985 - EXPECT_EQ(buf.pos, 9); 3.986 + CX_TEST_ASSERT(read == 0); 3.987 + CX_TEST_ASSERT(buf.pos == 9); 3.988 }
4.1 --- a/tests/ucxtest.c Mon Jan 01 15:33:20 2024 +0100 4.2 +++ b/tests/ucxtest.c Mon Jan 01 16:42:37 2024 +0100 4.3 @@ -34,6 +34,7 @@ 4.4 CxTestSuite *cx_test_suite_hash_key(void); 4.5 CxTestSuite *cx_test_suite_allocator(void); 4.6 CxTestSuite *cx_test_suite_string(void); 4.7 +CxTestSuite *cx_test_suite_buffer(void); 4.8 CxTestSuite *cx_test_suite_printf(void); 4.9 CxTestSuite *cx_test_suite_mempool(void); 4.10 CxTestSuite *cx_test_suite_hash_map(void); 4.11 @@ -53,6 +54,7 @@ 4.12 cx_test_suite_hash_key(), 4.13 cx_test_suite_allocator(), 4.14 cx_test_suite_string(), 4.15 + cx_test_suite_buffer(), 4.16 cx_test_suite_printf(), 4.17 cx_test_suite_mempool(), 4.18 cx_test_suite_hash_map()
