1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/tests/test_buffer.cpp Tue Feb 07 21:55:37 2023 +0100
1.3 @@ -0,0 +1,815 @@
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 +}
