1.1 --- a/test/test_buffer.cpp Tue Feb 07 21:53:06 2023 +0100
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,815 +0,0 @@
1.4 -/*
1.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
1.6 - *
1.7 - * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
1.8 - *
1.9 - * Redistribution and use in source and binary forms, with or without
1.10 - * modification, are permitted provided that the following conditions are met:
1.11 - *
1.12 - * 1. Redistributions of source code must retain the above copyright
1.13 - * notice, this list of conditions and the following disclaimer.
1.14 - *
1.15 - * 2. Redistributions in binary form must reproduce the above copyright
1.16 - * notice, this list of conditions and the following disclaimer in the
1.17 - * documentation and/or other materials provided with the distribution.
1.18 - *
1.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
1.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
1.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
1.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1.29 - * POSSIBILITY OF SUCH DAMAGE.
1.30 - */
1.31 -
1.32 -#include "cx/buffer.h"
1.33 -
1.34 -#include <gtest/gtest.h>
1.35 -#include "util_allocator.h"
1.36 -
1.37 -class BufferFixture : public ::testing::Test {
1.38 -protected:
1.39 - void SetUp() override {
1.40 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.41 - buf.size = 6;
1.42 - buf.pos = 3;
1.43 - }
1.44 -
1.45 - void TearDown() override {
1.46 - cxBufferDestroy(&buf);
1.47 - }
1.48 -
1.49 - CxBuffer buf{};
1.50 -};
1.51 -
1.52 -static void expect_default_flush_config(CxBuffer *buf) {
1.53 - EXPECT_EQ(buf->flush_blkmax, 0);
1.54 - EXPECT_EQ(buf->flush_blksize, 4096);
1.55 - EXPECT_EQ(buf->flush_threshold, SIZE_MAX);
1.56 - EXPECT_EQ(buf->flush_func, nullptr);
1.57 - EXPECT_EQ(buf->flush_target, nullptr);
1.58 -}
1.59 -
1.60 -TEST(BufferInit, WrapSpace) {
1.61 - CxTestingAllocator alloc;
1.62 - CxBuffer buf;
1.63 - void *space = cxMalloc(&alloc, 16);
1.64 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_DEFAULT);
1.65 - expect_default_flush_config(&buf);
1.66 - EXPECT_EQ(buf.space, space);
1.67 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
1.68 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0);
1.69 - EXPECT_EQ(buf.pos, 0);
1.70 - EXPECT_EQ(buf.size, 0);
1.71 - EXPECT_EQ(buf.capacity, 16);
1.72 - EXPECT_EQ(buf.allocator, &alloc);
1.73 - cxBufferDestroy(&buf);
1.74 - EXPECT_FALSE(alloc.verify());
1.75 - cxFree(&alloc, space);
1.76 - EXPECT_TRUE(alloc.verify());
1.77 -}
1.78 -
1.79 -TEST(BufferInit, WrapSpaceAutoExtend) {
1.80 - CxTestingAllocator alloc;
1.81 - CxBuffer buf;
1.82 - void *space = cxMalloc(&alloc, 16);
1.83 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_AUTO_EXTEND);
1.84 - expect_default_flush_config(&buf);
1.85 - EXPECT_EQ(buf.space, space);
1.86 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, CX_BUFFER_AUTO_EXTEND);
1.87 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0);
1.88 - EXPECT_EQ(buf.pos, 0);
1.89 - EXPECT_EQ(buf.size, 0);
1.90 - EXPECT_EQ(buf.capacity, 16);
1.91 - EXPECT_EQ(buf.allocator, &alloc);
1.92 - cxBufferDestroy(&buf);
1.93 - EXPECT_FALSE(alloc.verify());
1.94 - cxFree(&alloc, space);
1.95 - EXPECT_TRUE(alloc.verify());
1.96 -}
1.97 -
1.98 -TEST(BufferInit, WrapSpaceAutoFree) {
1.99 - CxTestingAllocator alloc;
1.100 - CxBuffer buf;
1.101 - void *space = cxMalloc(&alloc, 16);
1.102 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_FREE_CONTENTS);
1.103 - expect_default_flush_config(&buf);
1.104 - EXPECT_EQ(buf.space, space);
1.105 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
1.106 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);
1.107 - EXPECT_EQ(buf.pos, 0);
1.108 - EXPECT_EQ(buf.size, 0);
1.109 - EXPECT_EQ(buf.capacity, 16);
1.110 - EXPECT_EQ(buf.allocator, &alloc);
1.111 - EXPECT_FALSE(alloc.verify());
1.112 - cxBufferDestroy(&buf);
1.113 - EXPECT_TRUE(alloc.verify());
1.114 -}
1.115 -
1.116 -TEST(BufferInit, FreshSpace) {
1.117 - CxTestingAllocator alloc;
1.118 - CxBuffer buf;
1.119 - cxBufferInit(&buf, nullptr, 8, &alloc, CX_BUFFER_DEFAULT);
1.120 - expect_default_flush_config(&buf);
1.121 - EXPECT_NE(buf.space, nullptr);
1.122 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
1.123 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);
1.124 - EXPECT_EQ(buf.pos, 0);
1.125 - EXPECT_EQ(buf.size, 0);
1.126 - EXPECT_EQ(buf.capacity, 8);
1.127 - EXPECT_EQ(buf.allocator, &alloc);
1.128 - EXPECT_FALSE(alloc.verify()); // space is still allocated
1.129 - cxBufferDestroy(&buf);
1.130 - EXPECT_TRUE(alloc.verify());
1.131 -}
1.132 -
1.133 -class BufferShiftFixture : public ::testing::Test {
1.134 -protected:
1.135 - void SetUp() override {
1.136 - ASSERT_TRUE(alloc.verify());
1.137 - cxBufferInit(&buf, nullptr, 16, &alloc, CX_BUFFER_DEFAULT);
1.138 - memcpy(buf.space, "test____________", 16);
1.139 - buf.capacity = 8; // purposely pretend that the buffer has less capacity s.t. we can test beyond the range
1.140 - buf.pos = 4;
1.141 - buf.size = 4;
1.142 - }
1.143 -
1.144 - void TearDown() override {
1.145 - cxBufferDestroy(&buf);
1.146 - EXPECT_TRUE(alloc.verify());
1.147 - }
1.148 -
1.149 - CxTestingAllocator alloc;
1.150 - CxBuffer buf{};
1.151 -};
1.152 -
1.153 -class BufferShiftLeft : public BufferShiftFixture {
1.154 -};
1.155 -
1.156 -TEST_F(BufferShiftLeft, Zero) {
1.157 - ASSERT_EQ(buf.pos, 4);
1.158 - ASSERT_EQ(buf.size, 4);
1.159 - int ret = cxBufferShiftLeft(&buf, 0);
1.160 - EXPECT_EQ(ret, 0);
1.161 - EXPECT_EQ(buf.pos, 4);
1.162 - EXPECT_EQ(buf.size, 4);
1.163 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.164 -}
1.165 -
1.166 -TEST_F(BufferShiftLeft, ZeroOffsetInterface) {
1.167 - ASSERT_EQ(buf.pos, 4);
1.168 - ASSERT_EQ(buf.size, 4);
1.169 - int ret = cxBufferShift(&buf, -0);
1.170 - EXPECT_EQ(ret, 0);
1.171 - EXPECT_EQ(buf.pos, 4);
1.172 - EXPECT_EQ(buf.size, 4);
1.173 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.174 -}
1.175 -
1.176 -TEST_F(BufferShiftLeft, Standard) {
1.177 - ASSERT_EQ(buf.pos, 4);
1.178 - ASSERT_EQ(buf.size, 4);
1.179 - int ret = cxBufferShiftLeft(&buf, 2);
1.180 - EXPECT_EQ(ret, 0);
1.181 - EXPECT_EQ(buf.pos, 2);
1.182 - EXPECT_EQ(buf.size, 2);
1.183 - EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);
1.184 -}
1.185 -
1.186 -TEST_F(BufferShiftLeft, Overshift) {
1.187 - ASSERT_LT(buf.pos, 6);
1.188 - ASSERT_LT(buf.size, 6);
1.189 - int ret = cxBufferShiftLeft(&buf, 6);
1.190 - EXPECT_EQ(ret, 0);
1.191 - EXPECT_EQ(buf.pos, 0);
1.192 - EXPECT_EQ(buf.size, 0);
1.193 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.194 -}
1.195 -
1.196 -TEST_F(BufferShiftLeft, OvershiftPosOnly) {
1.197 - buf.pos = 2;
1.198 - ASSERT_EQ(buf.size, 4);
1.199 - int ret = cxBufferShiftLeft(&buf, 3);
1.200 - EXPECT_EQ(ret, 0);
1.201 - EXPECT_EQ(buf.pos, 0);
1.202 - EXPECT_EQ(buf.size, 1);
1.203 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.204 -}
1.205 -
1.206 -TEST_F(BufferShiftLeft, OffsetInterface) {
1.207 - buf.pos = 3;
1.208 - ASSERT_EQ(buf.size, 4);
1.209 - int ret = cxBufferShift(&buf, -2);
1.210 - EXPECT_EQ(ret, 0);
1.211 - EXPECT_EQ(buf.pos, 1);
1.212 - EXPECT_EQ(buf.size, 2);
1.213 - EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);
1.214 -}
1.215 -
1.216 -class BufferShiftRight : public BufferShiftFixture {
1.217 -};
1.218 -
1.219 -TEST_F(BufferShiftRight, Zero) {
1.220 - ASSERT_EQ(buf.pos, 4);
1.221 - ASSERT_EQ(buf.size, 4);
1.222 - int ret = cxBufferShiftRight(&buf, 0);
1.223 - EXPECT_EQ(ret, 0);
1.224 - EXPECT_EQ(buf.pos, 4);
1.225 - EXPECT_EQ(buf.size, 4);
1.226 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.227 -}
1.228 -
1.229 -TEST_F(BufferShiftRight, ZeroOffsetInterface) {
1.230 - ASSERT_EQ(buf.pos, 4);
1.231 - ASSERT_EQ(buf.size, 4);
1.232 - int ret = cxBufferShift(&buf, +0);
1.233 - EXPECT_EQ(ret, 0);
1.234 - EXPECT_EQ(buf.pos, 4);
1.235 - EXPECT_EQ(buf.size, 4);
1.236 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.237 -}
1.238 -
1.239 -TEST_F(BufferShiftRight, Standard) {
1.240 - ASSERT_EQ(buf.pos, 4);
1.241 - ASSERT_EQ(buf.size, 4);
1.242 - int ret = cxBufferShiftRight(&buf, 3);
1.243 - EXPECT_EQ(ret, 0);
1.244 - EXPECT_EQ(buf.pos, 7);
1.245 - EXPECT_EQ(buf.size, 7);
1.246 - EXPECT_TRUE(memcmp(buf.space, "testest_____", 8) == 0);
1.247 -}
1.248 -
1.249 -TEST_F(BufferShiftRight, OvershiftDiscard) {
1.250 - ASSERT_EQ(buf.pos, 4);
1.251 - ASSERT_EQ(buf.size, 4);
1.252 - ASSERT_EQ(buf.capacity, 8);
1.253 - int ret = cxBufferShiftRight(&buf, 6);
1.254 - EXPECT_EQ(ret, 0);
1.255 - EXPECT_EQ(buf.pos, 8);
1.256 - EXPECT_EQ(buf.size, 8);
1.257 - EXPECT_EQ(buf.capacity, 8);
1.258 - EXPECT_TRUE(memcmp(buf.space, "test__te____", 8) == 0);
1.259 -}
1.260 -
1.261 -TEST_F(BufferShiftRight, OvershiftExtend) {
1.262 - ASSERT_EQ(buf.pos, 4);
1.263 - ASSERT_EQ(buf.size, 4);
1.264 - ASSERT_EQ(buf.capacity, 8);
1.265 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.266 - int ret = cxBufferShiftRight(&buf, 6);
1.267 - EXPECT_EQ(ret, 0);
1.268 - EXPECT_EQ(buf.pos, 10);
1.269 - EXPECT_EQ(buf.size, 10);
1.270 - EXPECT_GE(buf.capacity, 10);
1.271 - EXPECT_TRUE(memcmp(buf.space, "test__test__", 8) == 0);
1.272 -}
1.273 -
1.274 -TEST_F(BufferShiftRight, OffsetInterface) {
1.275 - buf.pos = 3;
1.276 - ASSERT_EQ(buf.size, 4);
1.277 - int ret = cxBufferShift(&buf, 2);
1.278 - EXPECT_EQ(ret, 0);
1.279 - EXPECT_EQ(buf.pos, 5);
1.280 - EXPECT_EQ(buf.size, 6);
1.281 - EXPECT_TRUE(memcmp(buf.space, "tetest______", 8) == 0);
1.282 -}
1.283 -
1.284 -TEST(BufferMinimumCapacity, Sufficient) {
1.285 - CxTestingAllocator alloc;
1.286 - auto space = cxMalloc(&alloc, 8);
1.287 - CxBuffer buf;
1.288 - cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS);
1.289 - memcpy(space, "Testing", 8);
1.290 - buf.size = 8;
1.291 - cxBufferMinimumCapacity(&buf, 6);
1.292 - EXPECT_EQ(buf.capacity, 8);
1.293 - EXPECT_EQ(buf.size, 8);
1.294 - EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);
1.295 - cxBufferDestroy(&buf);
1.296 - EXPECT_TRUE(alloc.verify());
1.297 -}
1.298 -
1.299 -TEST(BufferMinimumCapacity, Extend) {
1.300 - CxTestingAllocator alloc;
1.301 - auto space = cxMalloc(&alloc, 8);
1.302 - CxBuffer buf;
1.303 - cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS); // NO auto extend!
1.304 - memcpy(space, "Testing", 8);
1.305 - buf.size = 8;
1.306 - cxBufferMinimumCapacity(&buf, 16);
1.307 - EXPECT_EQ(buf.capacity, 16);
1.308 - EXPECT_EQ(buf.size, 8);
1.309 - EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);
1.310 - cxBufferDestroy(&buf);
1.311 - EXPECT_TRUE(alloc.verify());
1.312 -}
1.313 -
1.314 -TEST(BufferClear, Test) {
1.315 - char space[16];
1.316 - strcpy(space, "clear test");
1.317 - CxBuffer buf;
1.318 - cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.319 - ASSERT_EQ(buf.size, 0);
1.320 - // only clear the used part of the buffer
1.321 - cxBufferClear(&buf);
1.322 - EXPECT_EQ(memcmp(space, "clear test", 10), 0);
1.323 - buf.size = 5;
1.324 - buf.pos = 3;
1.325 - cxBufferClear(&buf);
1.326 - EXPECT_EQ(memcmp(space, "\0\0\0\0\0 test", 10), 0);
1.327 - EXPECT_EQ(buf.size, 0);
1.328 - EXPECT_EQ(buf.pos, 0);
1.329 - cxBufferDestroy(&buf);
1.330 -}
1.331 -
1.332 -class BufferWrite : public ::testing::Test {
1.333 -protected:
1.334 - CxBuffer buf{}, target{};
1.335 -
1.336 - void SetUp() override {
1.337 - cxBufferInit(&target, nullptr, 16, cxDefaultAllocator, CX_BUFFER_AUTO_EXTEND);
1.338 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.339 - buf.capacity = 8; // artificially reduce capacity to check OOB writes
1.340 - memset(buf.space, 0, 16);
1.341 - memcpy(buf.space, "prep", 4);
1.342 - buf.size = buf.pos = 4;
1.343 - }
1.344 -
1.345 - void TearDown() override {
1.346 - cxBufferDestroy(&buf);
1.347 - cxBufferDestroy(&target);
1.348 - }
1.349 -
1.350 - void enableFlushing() {
1.351 - buf.flush_target = ⌖
1.352 - buf.flush_func = reinterpret_cast<cx_write_func>(cxBufferWrite);
1.353 - buf.flush_blkmax = 1;
1.354 - }
1.355 -};
1.356 -
1.357 -static size_t mock_write_limited_rate(
1.358 - void const *ptr,
1.359 - size_t size,
1.360 - __attribute__((unused)) size_t nitems,
1.361 - CxBuffer *buffer
1.362 -) {
1.363 - // simulate limited target drain capacity
1.364 - static bool full = false;
1.365 - if (full) {
1.366 - full = false;
1.367 - return 0;
1.368 - } else {
1.369 - full = true;
1.370 - return cxBufferWrite(ptr, size, nitems > 2 ? 2 : nitems, buffer);
1.371 - }
1.372 -}
1.373 -
1.374 -TEST_F(BufferWrite, SizeOneFit) {
1.375 - const char *data = "test";
1.376 - ASSERT_EQ(buf.capacity, 8);
1.377 - ASSERT_EQ(buf.pos, 4);
1.378 - ASSERT_EQ(buf.size, 4);
1.379 - size_t written = cxBufferWrite(data, 1, 4, &buf);
1.380 - EXPECT_EQ(written, 4);
1.381 - EXPECT_EQ(buf.size, 8);
1.382 - EXPECT_EQ(buf.pos, 8);
1.383 - EXPECT_EQ(buf.capacity, 8);
1.384 - EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0);
1.385 -}
1.386 -
1.387 -TEST_F(BufferWrite, SizeOneDiscard) {
1.388 - const char *data = "testing";
1.389 - ASSERT_EQ(buf.capacity, 8);
1.390 - ASSERT_EQ(buf.pos, 4);
1.391 - ASSERT_EQ(buf.size, 4);
1.392 - size_t written = cxBufferWrite(data, 1, 7, &buf);
1.393 - EXPECT_EQ(written, 4);
1.394 - EXPECT_EQ(buf.size, 8);
1.395 - EXPECT_EQ(buf.pos, 8);
1.396 - EXPECT_EQ(buf.capacity, 8);
1.397 - EXPECT_EQ(memcmp(buf.space, "preptest\0", 9), 0);
1.398 -}
1.399 -
1.400 -TEST_F(BufferWrite, SizeOneExtend) {
1.401 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.402 - const char *data = "testing";
1.403 - ASSERT_EQ(buf.capacity, 8);
1.404 - ASSERT_EQ(buf.pos, 4);
1.405 - ASSERT_EQ(buf.size, 4);
1.406 - size_t written = cxBufferWrite(data, 1, 7, &buf);
1.407 - EXPECT_EQ(written, 7);
1.408 - EXPECT_EQ(buf.size, 11);
1.409 - EXPECT_EQ(buf.pos, 11);
1.410 - EXPECT_GE(buf.capacity, 11);
1.411 - EXPECT_EQ(memcmp(buf.space, "preptesting", 11), 0);
1.412 -}
1.413 -
1.414 -TEST_F(BufferWrite, MultibyteFit) {
1.415 - const char *data = "test";
1.416 - ASSERT_EQ(buf.capacity, 8);
1.417 - ASSERT_EQ(buf.pos, 4);
1.418 - ASSERT_EQ(buf.size, 4);
1.419 - size_t written = cxBufferWrite(data, 2, 2, &buf);
1.420 - EXPECT_EQ(written, 2);
1.421 - EXPECT_EQ(buf.size, 8);
1.422 - EXPECT_EQ(buf.pos, 8);
1.423 - EXPECT_EQ(buf.capacity, 8);
1.424 - EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0);
1.425 -}
1.426 -
1.427 -TEST_F(BufferWrite, MultibyteDiscard) {
1.428 - const char *data = "testing";
1.429 - ASSERT_EQ(buf.capacity, 8);
1.430 - ASSERT_EQ(buf.size, 4);
1.431 - buf.pos = 3;
1.432 - size_t written = cxBufferWrite(data, 2, 4, &buf);
1.433 - // remember: whole elements are discarded if they do not fit
1.434 - EXPECT_EQ(written, 2);
1.435 - EXPECT_EQ(buf.size, 7);
1.436 - EXPECT_EQ(buf.pos, 7);
1.437 - EXPECT_EQ(buf.capacity, 8);
1.438 - EXPECT_EQ(memcmp(buf.space, "pretest\0", 8), 0);
1.439 -}
1.440 -
1.441 -TEST_F(BufferWrite, MultibyteExtend) {
1.442 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.443 - const char *data = "tester";
1.444 - ASSERT_EQ(buf.capacity, 8);
1.445 - ASSERT_EQ(buf.size, 4);
1.446 - buf.pos = 3;
1.447 - size_t written = cxBufferWrite(data, 2, 3, &buf);
1.448 - // remember: whole elements are discarded if they do not fit
1.449 - EXPECT_EQ(written, 3);
1.450 - EXPECT_EQ(buf.size, 9);
1.451 - EXPECT_EQ(buf.pos, 9);
1.452 - EXPECT_GE(buf.capacity, 9);
1.453 - EXPECT_EQ(memcmp(buf.space, "pretester", 9), 0);
1.454 -}
1.455 -
1.456 -TEST_F(BufferWrite, PutcWrapperFit) {
1.457 - ASSERT_EQ(buf.capacity, 8);
1.458 - ASSERT_EQ(buf.pos, 4);
1.459 - ASSERT_EQ(buf.size, 4);
1.460 - int c = cxBufferPut(&buf, 0x200 | 'a');
1.461 - EXPECT_EQ(c, 'a');
1.462 - EXPECT_EQ(buf.size, 5);
1.463 - EXPECT_EQ(buf.pos, 5);
1.464 - EXPECT_EQ(buf.capacity, 8);
1.465 - EXPECT_EQ(memcmp(buf.space, "prepa\0", 6), 0);
1.466 -}
1.467 -
1.468 -TEST_F(BufferWrite, PutcWrapperDiscard) {
1.469 - ASSERT_EQ(buf.capacity, 8);
1.470 - ASSERT_EQ(buf.size, 4);
1.471 - buf.pos = 8;
1.472 - int c = cxBufferPut(&buf, 0x200 | 'a');
1.473 - EXPECT_EQ(c, EOF);
1.474 - EXPECT_EQ(buf.size, 4);
1.475 - EXPECT_EQ(buf.pos, 8);
1.476 - EXPECT_EQ(buf.capacity, 8);
1.477 - EXPECT_EQ(memcmp(buf.space, "prep\0\0\0\0\0", 9), 0);
1.478 -}
1.479 -
1.480 -TEST_F(BufferWrite, PutcWrapperExtend) {
1.481 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.482 - ASSERT_EQ(buf.capacity, 8);
1.483 - ASSERT_EQ(buf.size, 4);
1.484 - buf.pos = 8;
1.485 - int c = cxBufferPut(&buf, 0x200 | 'a');
1.486 - EXPECT_EQ(c, 'a');
1.487 - EXPECT_EQ(buf.size, 9);
1.488 - EXPECT_EQ(buf.pos, 9);
1.489 - EXPECT_GE(buf.capacity, 9);
1.490 - EXPECT_EQ(memcmp(buf.space, "prep\0\0\0\0a", 9), 0);
1.491 -}
1.492 -
1.493 -TEST_F(BufferWrite, PutStringWrapperFit) {
1.494 - const char *data = "test";
1.495 - ASSERT_EQ(buf.capacity, 8);
1.496 - ASSERT_EQ(buf.pos, 4);
1.497 - ASSERT_EQ(buf.size, 4);
1.498 - size_t written = cxBufferPutString(&buf, data);
1.499 - EXPECT_EQ(written, 4);
1.500 - EXPECT_EQ(buf.size, 8);
1.501 - EXPECT_EQ(buf.pos, 8);
1.502 - EXPECT_EQ(buf.capacity, 8);
1.503 - EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0);
1.504 -}
1.505 -
1.506 -TEST_F(BufferWrite, PutStringWrapperDiscard) {
1.507 - const char *data = "testing";
1.508 - ASSERT_EQ(buf.capacity, 8);
1.509 - ASSERT_EQ(buf.pos, 4);
1.510 - ASSERT_EQ(buf.size, 4);
1.511 - size_t written = cxBufferPutString(&buf, data);
1.512 - EXPECT_EQ(written, 4);
1.513 - EXPECT_EQ(buf.size, 8);
1.514 - EXPECT_EQ(buf.pos, 8);
1.515 - EXPECT_EQ(buf.capacity, 8);
1.516 - EXPECT_EQ(memcmp(buf.space, "preptest\0", 9), 0);
1.517 -}
1.518 -
1.519 -TEST_F(BufferWrite, PutStringWrapperExtend) {
1.520 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.521 - const char *data = "testing";
1.522 - ASSERT_EQ(buf.capacity, 8);
1.523 - ASSERT_EQ(buf.pos, 4);
1.524 - ASSERT_EQ(buf.size, 4);
1.525 - size_t written = cxBufferPutString(&buf, data);
1.526 - EXPECT_EQ(written, 7);
1.527 - EXPECT_EQ(buf.size, 11);
1.528 - EXPECT_EQ(buf.pos, 11);
1.529 - EXPECT_GE(buf.capacity, 11);
1.530 - EXPECT_EQ(memcmp(buf.space, "preptesting", 11), 0);
1.531 -}
1.532 -
1.533 -TEST_F(BufferWrite, MultOverflow) {
1.534 - const char *data = "testing";
1.535 - ASSERT_EQ(buf.capacity, 8);
1.536 - ASSERT_EQ(buf.pos, 4);
1.537 - ASSERT_EQ(buf.size, 4);
1.538 - size_t written = cxBufferWrite(data, 8, SIZE_MAX / 4, &buf);
1.539 - EXPECT_EQ(written, 0);
1.540 - EXPECT_EQ(buf.capacity, 8);
1.541 - EXPECT_EQ(buf.pos, 4);
1.542 - EXPECT_EQ(buf.size, 4);
1.543 - EXPECT_EQ(memcmp(buf.space, "prep\0", 5), 0);
1.544 -}
1.545 -
1.546 -TEST_F(BufferWrite, MaxCapaOverflow) {
1.547 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.548 - const char *data = "testing";
1.549 - ASSERT_EQ(buf.capacity, 8);
1.550 - ASSERT_EQ(buf.pos, 4);
1.551 - ASSERT_EQ(buf.size, 4);
1.552 - size_t written = cxBufferWrite(data, 1, SIZE_MAX - 2, &buf);
1.553 - EXPECT_EQ(written, 0);
1.554 - EXPECT_EQ(buf.capacity, 8);
1.555 - EXPECT_EQ(buf.pos, 4);
1.556 - EXPECT_EQ(buf.size, 4);
1.557 - EXPECT_EQ(memcmp(buf.space, "prep\0", 5), 0);
1.558 -}
1.559 -
1.560 -TEST_F(BufferWrite, OnlyOverwrite) {
1.561 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.562 - ASSERT_EQ(buf.capacity, 8);
1.563 - memcpy(buf.space, "preptest", 8);
1.564 - buf.pos = 3;
1.565 - buf.size = 8;
1.566 - size_t written = cxBufferWrite("XXX", 2, 2, &buf);
1.567 - EXPECT_EQ(written, 2);
1.568 - EXPECT_EQ(buf.capacity, 8);
1.569 - EXPECT_EQ(buf.size, 8);
1.570 - EXPECT_EQ(buf.pos, 7);
1.571 - EXPECT_EQ(memcmp(buf.space, "preXXX\0t", 8), 0);
1.572 -}
1.573 -
1.574 -TEST_F(BufferWrite, FlushAtCapacity) {
1.575 - enableFlushing();
1.576 - ASSERT_EQ(buf.capacity, 8);
1.577 - ASSERT_EQ(buf.pos, 4);
1.578 - size_t written = cxBufferWrite("foo", 1, 3, &buf);
1.579 - EXPECT_EQ(written, 3);
1.580 - ASSERT_EQ(buf.pos, 7);
1.581 - ASSERT_EQ(buf.size, 7);
1.582 - ASSERT_EQ(target.pos, 0);
1.583 - ASSERT_EQ(target.size, 0);
1.584 - written = cxBufferWrite("hello", 1, 5, &buf);
1.585 - EXPECT_EQ(written, 5);
1.586 - EXPECT_EQ(buf.pos, 0);
1.587 - EXPECT_EQ(buf.size, 0);
1.588 - EXPECT_EQ(buf.capacity, 8);
1.589 - EXPECT_EQ(target.pos, 12);
1.590 - ASSERT_EQ(target.size, 12);
1.591 - EXPECT_EQ(memcmp(target.space, "prepfoohello", 12), 0);
1.592 -}
1.593 -
1.594 -TEST_F(BufferWrite, FlushAtThreshold) {
1.595 - enableFlushing();
1.596 - buf.flush_threshold = 12;
1.597 - buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.598 - ASSERT_EQ(buf.capacity, 8);
1.599 - ASSERT_EQ(buf.pos, 4);
1.600 - size_t written = cxBufferWrite("foobar", 1, 6, &buf);
1.601 - EXPECT_EQ(written, 6);
1.602 - ASSERT_EQ(buf.pos, 10);
1.603 - ASSERT_EQ(buf.size, 10);
1.604 - ASSERT_GE(buf.capacity, 10);
1.605 - ASSERT_LE(buf.capacity, 12);
1.606 - ASSERT_EQ(target.pos, 0);
1.607 - ASSERT_EQ(target.size, 0);
1.608 - written = cxBufferWrite("hello", 1, 5, &buf);
1.609 - EXPECT_EQ(written, 5);
1.610 - EXPECT_EQ(buf.pos, 0);
1.611 - EXPECT_EQ(buf.size, 0);
1.612 - EXPECT_LE(buf.capacity, 12);
1.613 - EXPECT_EQ(target.pos, 15);
1.614 - ASSERT_EQ(target.size, 15);
1.615 - EXPECT_EQ(memcmp(target.space, "prepfoobarhello", 15), 0);
1.616 -}
1.617 -
1.618 -TEST_F(BufferWrite, FlushRateLimited) {
1.619 - enableFlushing();
1.620 - // limit the rate of the flush function and the capacity of the target
1.621 - target.capacity = 16;
1.622 - target.flags &= ~CX_BUFFER_AUTO_EXTEND;
1.623 - buf.flush_func = (cx_write_func) mock_write_limited_rate;
1.624 - ASSERT_EQ(buf.capacity, 8);
1.625 - ASSERT_EQ(buf.pos, 4);
1.626 - size_t written = cxBufferWrite("foo", 1, 3, &buf);
1.627 - EXPECT_EQ(written, 3);
1.628 - ASSERT_EQ(buf.pos, 7);
1.629 - ASSERT_EQ(buf.size, 7);
1.630 - ASSERT_EQ(target.pos, 0);
1.631 - ASSERT_EQ(target.size, 0);
1.632 - written = cxBufferWrite("hello, world!", 1, 13, &buf);
1.633 - // " world!" fits into this buffer, the remaining stuff is flushed out
1.634 - EXPECT_EQ(written, 13);
1.635 - EXPECT_EQ(buf.pos, 7);
1.636 - EXPECT_EQ(buf.size, 7);
1.637 - EXPECT_EQ(buf.capacity, 8);
1.638 - EXPECT_EQ(memcmp(buf.space, " world!", 7), 0);
1.639 - EXPECT_EQ(target.pos, 13);
1.640 - ASSERT_EQ(target.size, 13);
1.641 - EXPECT_EQ(target.capacity, 16);
1.642 - EXPECT_EQ(memcmp(target.space, "prepfoohello,", 13), 0);
1.643 -}
1.644 -
1.645 -class BufferSeek : public BufferFixture {
1.646 -};
1.647 -
1.648 -TEST_F(BufferSeek, SetZero) {
1.649 - int result = cxBufferSeek(&buf, 0, SEEK_SET);
1.650 - EXPECT_EQ(result, 0);
1.651 - EXPECT_EQ(buf.pos, 0);
1.652 -}
1.653 -
1.654 -TEST_F(BufferSeek, SetValid) {
1.655 - int result = cxBufferSeek(&buf, 5, SEEK_SET);
1.656 - EXPECT_EQ(result, 0);
1.657 - EXPECT_EQ(buf.pos, 5);
1.658 -}
1.659 -
1.660 -TEST_F(BufferSeek, SetInvalid) {
1.661 - ASSERT_EQ(buf.pos, 3);
1.662 - int result = cxBufferSeek(&buf, 6, SEEK_SET);
1.663 - EXPECT_NE(result, 0);
1.664 - EXPECT_EQ(buf.pos, 3);
1.665 -}
1.666 -
1.667 -TEST_F(BufferSeek, CurZero) {
1.668 - ASSERT_EQ(buf.pos, 3);
1.669 - int result = cxBufferSeek(&buf, 0, SEEK_CUR);
1.670 - EXPECT_EQ(result, 0);
1.671 - EXPECT_EQ(buf.pos, 3);
1.672 -}
1.673 -
1.674 -TEST_F(BufferSeek, CurValidPositive) {
1.675 - ASSERT_EQ(buf.pos, 3);
1.676 - int result = cxBufferSeek(&buf, 2, SEEK_CUR);
1.677 - EXPECT_EQ(result, 0);
1.678 - EXPECT_EQ(buf.pos, 5);
1.679 -}
1.680 -
1.681 -TEST_F(BufferSeek, CurValidNegative) {
1.682 - ASSERT_EQ(buf.pos, 3);
1.683 - int result = cxBufferSeek(&buf, -3, SEEK_CUR);
1.684 - EXPECT_EQ(result, 0);
1.685 - EXPECT_EQ(buf.pos, 0);
1.686 -}
1.687 -
1.688 -TEST_F(BufferSeek, CurInvalidPositive) {
1.689 - ASSERT_EQ(buf.pos, 3);
1.690 - int result = cxBufferSeek(&buf, 3, SEEK_CUR);
1.691 - EXPECT_NE(result, 0);
1.692 - EXPECT_EQ(buf.pos, 3);
1.693 -}
1.694 -
1.695 -TEST_F(BufferSeek, CurInvalidNegative) {
1.696 - ASSERT_EQ(buf.pos, 3);
1.697 - int result = cxBufferSeek(&buf, -4, SEEK_CUR);
1.698 - EXPECT_NE(result, 0);
1.699 - EXPECT_EQ(buf.pos, 3);
1.700 -}
1.701 -
1.702 -TEST_F(BufferSeek, EndZero) {
1.703 - ASSERT_EQ(buf.size, 6);
1.704 - int result = cxBufferSeek(&buf, 0, SEEK_END);
1.705 - // the (past-the-)end position is always invalid
1.706 - EXPECT_NE(result, 0);
1.707 - EXPECT_EQ(buf.pos, 3);
1.708 -}
1.709 -
1.710 -TEST_F(BufferSeek, EndValid) {
1.711 - ASSERT_EQ(buf.size, 6);
1.712 - int result = cxBufferSeek(&buf, -6, SEEK_END);
1.713 - EXPECT_EQ(result, 0);
1.714 - EXPECT_EQ(buf.pos, 0);
1.715 -}
1.716 -
1.717 -TEST_F(BufferSeek, EndInvalid) {
1.718 - ASSERT_EQ(buf.size, 6);
1.719 - int result = cxBufferSeek(&buf, 1, SEEK_END);
1.720 - EXPECT_NE(result, 0);
1.721 - EXPECT_EQ(buf.pos, 3);
1.722 -}
1.723 -
1.724 -TEST_F(BufferSeek, WhenceInvalid) {
1.725 - ASSERT_EQ(buf.size, 6);
1.726 - ASSERT_EQ(buf.pos, 3);
1.727 - int result = cxBufferSeek(&buf, 2, 9000);
1.728 - EXPECT_NE(result, 0);
1.729 - EXPECT_EQ(buf.size, 6);
1.730 - EXPECT_EQ(buf.pos, 3);
1.731 -}
1.732 -
1.733 -class BufferEof : public BufferFixture {
1.734 -};
1.735 -
1.736 -TEST_F(BufferEof, Reached) {
1.737 - buf.pos = buf.size;
1.738 - EXPECT_TRUE(cxBufferEof(&buf));
1.739 - buf.pos = buf.size - 1;
1.740 - ASSERT_FALSE(cxBufferEof(&buf));
1.741 - cxBufferPut(&buf, 'a');
1.742 - EXPECT_TRUE(cxBufferEof(&buf));
1.743 -}
1.744 -
1.745 -TEST_F(BufferEof, NotReached) {
1.746 - buf.pos = buf.size - 1;
1.747 - EXPECT_FALSE(cxBufferEof(&buf));
1.748 - buf.pos = 0;
1.749 - cxBufferWrite("test", 1, 5, &buf);
1.750 - EXPECT_FALSE(cxBufferEof(&buf));
1.751 -}
1.752 -
1.753 -class BufferRead : public ::testing::Test {
1.754 -protected:
1.755 - CxBuffer buf{};
1.756 -
1.757 - void SetUp() override {
1.758 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.759 - buf.capacity = 8; // artificially reduce capacity to check OOB writes
1.760 - memset(buf.space, 0, 16);
1.761 - memcpy(buf.space, "some data", 9);
1.762 - buf.size = 9;
1.763 - }
1.764 -
1.765 - void TearDown() override {
1.766 - cxBufferDestroy(&buf);
1.767 - }
1.768 -};
1.769 -
1.770 -TEST_F(BufferRead, GetByte) {
1.771 - buf.pos = 2;
1.772 - EXPECT_EQ(cxBufferGet(&buf), 'm');
1.773 - EXPECT_EQ(cxBufferGet(&buf), 'e');
1.774 - EXPECT_EQ(cxBufferGet(&buf), ' ');
1.775 - EXPECT_EQ(cxBufferGet(&buf), 'd');
1.776 - EXPECT_EQ(buf.pos, 6);
1.777 -}
1.778 -
1.779 -TEST_F(BufferRead, GetEof) {
1.780 - buf.pos = buf.size;
1.781 - EXPECT_EQ(cxBufferGet(&buf), EOF);
1.782 -}
1.783 -
1.784 -TEST_F(BufferRead, ReadWithinBounds) {
1.785 - buf.pos = 2;
1.786 - char target[4];
1.787 - auto read = cxBufferRead(&target, 1, 4, &buf);
1.788 - ASSERT_EQ(read, 4);
1.789 - EXPECT_EQ(memcmp(&target, "me d", 4), 0);
1.790 - EXPECT_EQ(buf.pos, 6);
1.791 -}
1.792 -
1.793 -TEST_F(BufferRead, ReadOutOfBounds) {
1.794 - buf.pos = 6;
1.795 - char target[4];
1.796 - auto read = cxBufferRead(&target, 1, 4, &buf);
1.797 - ASSERT_EQ(read, 3);
1.798 - EXPECT_EQ(memcmp(&target, "ata", 3), 0);
1.799 - EXPECT_EQ(buf.pos, 9);
1.800 -}
1.801 -
1.802 -TEST_F(BufferRead, ReadOutOfBoundsMultibyte) {
1.803 - buf.pos = 6;
1.804 - char target[4];
1.805 - target[2] = '\0';
1.806 - auto read = cxBufferRead(&target, 2, 2, &buf);
1.807 - ASSERT_EQ(read, 1);
1.808 - EXPECT_EQ(memcmp(&target, "at\0", 3), 0);
1.809 - EXPECT_EQ(buf.pos, 8);
1.810 -}
1.811 -
1.812 -TEST_F(BufferRead, ReadEof) {
1.813 - buf.pos = 9;
1.814 - char target[4];
1.815 - auto read = cxBufferRead(&target, 1, 1, &buf);
1.816 - ASSERT_EQ(read, 0);
1.817 - EXPECT_EQ(buf.pos, 9);
1.818 -}
