1.1 --- a/tests/test_buffer.cpp Mon Jan 01 15:33:20 2024 +0100
1.2 +++ b/tests/test_buffer.cpp Mon Jan 01 16:42:37 2024 +0100
1.3 @@ -34,7 +34,7 @@
1.4 class BufferFixture : public ::testing::Test {
1.5 protected:
1.6 void SetUp() override {
1.7 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.8 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.9 buf.size = 6;
1.10 buf.pos = 3;
1.11 }
1.12 @@ -46,110 +46,11 @@
1.13 CxBuffer buf{};
1.14 };
1.15
1.16 -static void expect_default_flush_config(CxBuffer *buf) {
1.17 - EXPECT_EQ(buf->flush_blkmax, 0);
1.18 - EXPECT_EQ(buf->flush_blksize, 4096);
1.19 - EXPECT_EQ(buf->flush_threshold, SIZE_MAX);
1.20 - EXPECT_EQ(buf->flush_func, nullptr);
1.21 - EXPECT_EQ(buf->flush_target, nullptr);
1.22 -}
1.23 -
1.24 -TEST(BufferInit, WrapSpace) {
1.25 - CxTestingAllocator alloc;
1.26 - CxBuffer buf;
1.27 - void *space = cxMalloc(&alloc, 16);
1.28 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_DEFAULT);
1.29 - expect_default_flush_config(&buf);
1.30 - EXPECT_EQ(buf.space, space);
1.31 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
1.32 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0);
1.33 - EXPECT_EQ(buf.pos, 0);
1.34 - EXPECT_EQ(buf.size, 0);
1.35 - EXPECT_EQ(buf.capacity, 16);
1.36 - EXPECT_EQ(buf.allocator, &alloc);
1.37 - cxBufferDestroy(&buf);
1.38 - EXPECT_FALSE(alloc.verify());
1.39 - cxFree(&alloc, space);
1.40 - EXPECT_TRUE(alloc.verify());
1.41 -}
1.42 -
1.43 -TEST(BufferInit, WrapSpaceAutoExtend) {
1.44 - CxTestingAllocator alloc;
1.45 - CxBuffer buf;
1.46 - void *space = cxMalloc(&alloc, 16);
1.47 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_AUTO_EXTEND);
1.48 - expect_default_flush_config(&buf);
1.49 - EXPECT_EQ(buf.space, space);
1.50 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, CX_BUFFER_AUTO_EXTEND);
1.51 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0);
1.52 - EXPECT_EQ(buf.pos, 0);
1.53 - EXPECT_EQ(buf.size, 0);
1.54 - EXPECT_EQ(buf.capacity, 16);
1.55 - EXPECT_EQ(buf.allocator, &alloc);
1.56 - cxBufferDestroy(&buf);
1.57 - EXPECT_FALSE(alloc.verify());
1.58 - cxFree(&alloc, space);
1.59 - EXPECT_TRUE(alloc.verify());
1.60 -}
1.61 -
1.62 -TEST(BufferInit, WrapSpaceAutoFree) {
1.63 - CxTestingAllocator alloc;
1.64 - CxBuffer buf;
1.65 - void *space = cxMalloc(&alloc, 16);
1.66 - cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_FREE_CONTENTS);
1.67 - expect_default_flush_config(&buf);
1.68 - EXPECT_EQ(buf.space, space);
1.69 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
1.70 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);
1.71 - EXPECT_EQ(buf.pos, 0);
1.72 - EXPECT_EQ(buf.size, 0);
1.73 - EXPECT_EQ(buf.capacity, 16);
1.74 - EXPECT_EQ(buf.allocator, &alloc);
1.75 - EXPECT_FALSE(alloc.verify());
1.76 - cxBufferDestroy(&buf);
1.77 - EXPECT_TRUE(alloc.verify());
1.78 -}
1.79 -
1.80 -TEST(BufferInit, FreshSpace) {
1.81 - CxTestingAllocator alloc;
1.82 - CxBuffer buf;
1.83 - cxBufferInit(&buf, nullptr, 8, &alloc, CX_BUFFER_DEFAULT);
1.84 - expect_default_flush_config(&buf);
1.85 - EXPECT_NE(buf.space, nullptr);
1.86 - EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
1.87 - EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);
1.88 - EXPECT_EQ(buf.pos, 0);
1.89 - EXPECT_EQ(buf.size, 0);
1.90 - EXPECT_EQ(buf.capacity, 8);
1.91 - EXPECT_EQ(buf.allocator, &alloc);
1.92 - EXPECT_FALSE(alloc.verify()); // space is still allocated
1.93 - cxBufferDestroy(&buf);
1.94 - EXPECT_TRUE(alloc.verify());
1.95 -}
1.96 -
1.97 -TEST(BufferInit, OnHeap) {
1.98 - CxTestingAllocator alloc;
1.99 - CxBuffer *buf;
1.100 - void *space = cxMalloc(&alloc, 16);
1.101 - buf = cxBufferCreate(space, 16, &alloc, CX_BUFFER_FREE_CONTENTS);
1.102 - EXPECT_NE(buf, nullptr);
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 - cxBufferFree(buf);
1.112 - EXPECT_TRUE(alloc.verify());
1.113 -}
1.114 -
1.115 class BufferShiftFixture : public ::testing::Test {
1.116 protected:
1.117 void SetUp() override {
1.118 - ASSERT_TRUE(alloc.verify());
1.119 - cxBufferInit(&buf, nullptr, 16, &alloc, CX_BUFFER_DEFAULT);
1.120 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
1.121 + cxBufferInit(&buf, NULL, 16, &alloc, CX_BUFFER_DEFAULT);
1.122 memcpy(buf.space, "test____________", 16);
1.123 buf.capacity = 8; // purposely pretend that the buffer has less capacity s.t. we can test beyond the range
1.124 buf.pos = 4;
1.125 @@ -158,7 +59,7 @@
1.126
1.127 void TearDown() override {
1.128 cxBufferDestroy(&buf);
1.129 - EXPECT_TRUE(alloc.verify());
1.130 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
1.131 }
1.132
1.133 CxTestingAllocator alloc;
1.134 @@ -169,193 +70,128 @@
1.135 };
1.136
1.137 TEST_F(BufferShiftLeft, Zero) {
1.138 - ASSERT_EQ(buf.pos, 4);
1.139 - ASSERT_EQ(buf.size, 4);
1.140 + CX_TEST_ASSERT(buf.pos == 4);
1.141 + CX_TEST_ASSERT(buf.size == 4);
1.142 int ret = cxBufferShiftLeft(&buf, 0);
1.143 - EXPECT_EQ(ret, 0);
1.144 - EXPECT_EQ(buf.pos, 4);
1.145 - EXPECT_EQ(buf.size, 4);
1.146 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.147 + CX_TEST_ASSERT(ret == 0);
1.148 + CX_TEST_ASSERT(buf.pos == 4);
1.149 + CX_TEST_ASSERT(buf.size == 4);
1.150 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
1.151 }
1.152
1.153 TEST_F(BufferShiftLeft, ZeroOffsetInterface) {
1.154 - ASSERT_EQ(buf.pos, 4);
1.155 - ASSERT_EQ(buf.size, 4);
1.156 + CX_TEST_ASSERT(buf.pos == 4);
1.157 + CX_TEST_ASSERT(buf.size == 4);
1.158 int ret = cxBufferShift(&buf, -0);
1.159 - EXPECT_EQ(ret, 0);
1.160 - EXPECT_EQ(buf.pos, 4);
1.161 - EXPECT_EQ(buf.size, 4);
1.162 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.163 + CX_TEST_ASSERT(ret == 0);
1.164 + CX_TEST_ASSERT(buf.pos == 4);
1.165 + CX_TEST_ASSERT(buf.size == 4);
1.166 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
1.167 }
1.168
1.169 TEST_F(BufferShiftLeft, Standard) {
1.170 - ASSERT_EQ(buf.pos, 4);
1.171 - ASSERT_EQ(buf.size, 4);
1.172 + CX_TEST_ASSERT(buf.pos == 4);
1.173 + CX_TEST_ASSERT(buf.size == 4);
1.174 int ret = cxBufferShiftLeft(&buf, 2);
1.175 - EXPECT_EQ(ret, 0);
1.176 - EXPECT_EQ(buf.pos, 2);
1.177 - EXPECT_EQ(buf.size, 2);
1.178 - EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);
1.179 + CX_TEST_ASSERT(ret == 0);
1.180 + CX_TEST_ASSERT(buf.pos == 2);
1.181 + CX_TEST_ASSERT(buf.size == 2);
1.182 + CX_TEST_ASSERT(memcmp(buf.space, "stst________", 8) == 0);
1.183 }
1.184
1.185 TEST_F(BufferShiftLeft, Overshift) {
1.186 ASSERT_LT(buf.pos, 6);
1.187 ASSERT_LT(buf.size, 6);
1.188 int ret = cxBufferShiftLeft(&buf, 6);
1.189 - EXPECT_EQ(ret, 0);
1.190 - EXPECT_EQ(buf.pos, 0);
1.191 - EXPECT_EQ(buf.size, 0);
1.192 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.193 + CX_TEST_ASSERT(ret == 0);
1.194 + CX_TEST_ASSERT(buf.pos == 0);
1.195 + CX_TEST_ASSERT(buf.size == 0);
1.196 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
1.197 }
1.198
1.199 TEST_F(BufferShiftLeft, OvershiftPosOnly) {
1.200 buf.pos = 2;
1.201 - ASSERT_EQ(buf.size, 4);
1.202 + CX_TEST_ASSERT(buf.size == 4);
1.203 int ret = cxBufferShiftLeft(&buf, 3);
1.204 - EXPECT_EQ(ret, 0);
1.205 - EXPECT_EQ(buf.pos, 0);
1.206 - EXPECT_EQ(buf.size, 1);
1.207 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.208 + CX_TEST_ASSERT(ret == 0);
1.209 + CX_TEST_ASSERT(buf.pos == 0);
1.210 + CX_TEST_ASSERT(buf.size == 1);
1.211 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
1.212 }
1.213
1.214 TEST_F(BufferShiftLeft, OffsetInterface) {
1.215 buf.pos = 3;
1.216 - ASSERT_EQ(buf.size, 4);
1.217 + CX_TEST_ASSERT(buf.size == 4);
1.218 int ret = cxBufferShift(&buf, -2);
1.219 - EXPECT_EQ(ret, 0);
1.220 - EXPECT_EQ(buf.pos, 1);
1.221 - EXPECT_EQ(buf.size, 2);
1.222 - EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);
1.223 + CX_TEST_ASSERT(ret == 0);
1.224 + CX_TEST_ASSERT(buf.pos == 1);
1.225 + CX_TEST_ASSERT(buf.size == 2);
1.226 + CX_TEST_ASSERT(memcmp(buf.space, "stst________", 8) == 0);
1.227 }
1.228
1.229 -class BufferShiftRight : public BufferShiftFixture {
1.230 -};
1.231 -
1.232 TEST_F(BufferShiftRight, Zero) {
1.233 - ASSERT_EQ(buf.pos, 4);
1.234 - ASSERT_EQ(buf.size, 4);
1.235 + CX_TEST_ASSERT(buf.pos == 4);
1.236 + CX_TEST_ASSERT(buf.size == 4);
1.237 int ret = cxBufferShiftRight(&buf, 0);
1.238 - EXPECT_EQ(ret, 0);
1.239 - EXPECT_EQ(buf.pos, 4);
1.240 - EXPECT_EQ(buf.size, 4);
1.241 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.242 + CX_TEST_ASSERT(ret == 0);
1.243 + CX_TEST_ASSERT(buf.pos == 4);
1.244 + CX_TEST_ASSERT(buf.size == 4);
1.245 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
1.246 }
1.247
1.248 TEST_F(BufferShiftRight, ZeroOffsetInterface) {
1.249 - ASSERT_EQ(buf.pos, 4);
1.250 - ASSERT_EQ(buf.size, 4);
1.251 + CX_TEST_ASSERT(buf.pos == 4);
1.252 + CX_TEST_ASSERT(buf.size == 4);
1.253 int ret = cxBufferShift(&buf, +0);
1.254 - EXPECT_EQ(ret, 0);
1.255 - EXPECT_EQ(buf.pos, 4);
1.256 - EXPECT_EQ(buf.size, 4);
1.257 - EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
1.258 + CX_TEST_ASSERT(ret == 0);
1.259 + CX_TEST_ASSERT(buf.pos == 4);
1.260 + CX_TEST_ASSERT(buf.size == 4);
1.261 + CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
1.262 }
1.263
1.264 TEST_F(BufferShiftRight, Standard) {
1.265 - ASSERT_EQ(buf.pos, 4);
1.266 - ASSERT_EQ(buf.size, 4);
1.267 + CX_TEST_ASSERT(buf.pos == 4);
1.268 + CX_TEST_ASSERT(buf.size == 4);
1.269 int ret = cxBufferShiftRight(&buf, 3);
1.270 - EXPECT_EQ(ret, 0);
1.271 - EXPECT_EQ(buf.pos, 7);
1.272 - EXPECT_EQ(buf.size, 7);
1.273 - EXPECT_TRUE(memcmp(buf.space, "testest_____", 8) == 0);
1.274 + CX_TEST_ASSERT(ret == 0);
1.275 + CX_TEST_ASSERT(buf.pos == 7);
1.276 + CX_TEST_ASSERT(buf.size == 7);
1.277 + CX_TEST_ASSERT(memcmp(buf.space, "testest_____", 8) == 0);
1.278 }
1.279
1.280 TEST_F(BufferShiftRight, OvershiftDiscard) {
1.281 - ASSERT_EQ(buf.pos, 4);
1.282 - ASSERT_EQ(buf.size, 4);
1.283 - ASSERT_EQ(buf.capacity, 8);
1.284 + CX_TEST_ASSERT(buf.pos == 4);
1.285 + CX_TEST_ASSERT(buf.size == 4);
1.286 + CX_TEST_ASSERT(buf.capacity == 8);
1.287 int ret = cxBufferShiftRight(&buf, 6);
1.288 - EXPECT_EQ(ret, 0);
1.289 - EXPECT_EQ(buf.pos, 8);
1.290 - EXPECT_EQ(buf.size, 8);
1.291 - EXPECT_EQ(buf.capacity, 8);
1.292 - EXPECT_TRUE(memcmp(buf.space, "test__te____", 8) == 0);
1.293 + CX_TEST_ASSERT(ret == 0);
1.294 + CX_TEST_ASSERT(buf.pos == 8);
1.295 + CX_TEST_ASSERT(buf.size == 8);
1.296 + CX_TEST_ASSERT(buf.capacity == 8);
1.297 + CX_TEST_ASSERT(memcmp(buf.space, "test__te____", 8) == 0);
1.298 }
1.299
1.300 TEST_F(BufferShiftRight, OvershiftExtend) {
1.301 - ASSERT_EQ(buf.pos, 4);
1.302 - ASSERT_EQ(buf.size, 4);
1.303 - ASSERT_EQ(buf.capacity, 8);
1.304 + CX_TEST_ASSERT(buf.pos == 4);
1.305 + CX_TEST_ASSERT(buf.size == 4);
1.306 + CX_TEST_ASSERT(buf.capacity == 8);
1.307 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.308 int ret = cxBufferShiftRight(&buf, 6);
1.309 - EXPECT_EQ(ret, 0);
1.310 - EXPECT_EQ(buf.pos, 10);
1.311 - EXPECT_EQ(buf.size, 10);
1.312 + CX_TEST_ASSERT(ret == 0);
1.313 + CX_TEST_ASSERT(buf.pos == 10);
1.314 + CX_TEST_ASSERT(buf.size == 10);
1.315 EXPECT_GE(buf.capacity, 10);
1.316 - EXPECT_TRUE(memcmp(buf.space, "test__test__", 8) == 0);
1.317 + CX_TEST_ASSERT(memcmp(buf.space, "test__test__", 8) == 0);
1.318 }
1.319
1.320 TEST_F(BufferShiftRight, OffsetInterface) {
1.321 buf.pos = 3;
1.322 - ASSERT_EQ(buf.size, 4);
1.323 + CX_TEST_ASSERT(buf.size == 4);
1.324 int ret = cxBufferShift(&buf, 2);
1.325 - EXPECT_EQ(ret, 0);
1.326 - EXPECT_EQ(buf.pos, 5);
1.327 - EXPECT_EQ(buf.size, 6);
1.328 - EXPECT_TRUE(memcmp(buf.space, "tetest______", 8) == 0);
1.329 -}
1.330 -
1.331 -TEST(BufferMinimumCapacity, Sufficient) {
1.332 - CxTestingAllocator alloc;
1.333 - auto space = cxMalloc(&alloc, 8);
1.334 - CxBuffer buf;
1.335 - cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS);
1.336 - memcpy(space, "Testing", 8);
1.337 - buf.size = 8;
1.338 - cxBufferMinimumCapacity(&buf, 6);
1.339 - EXPECT_EQ(buf.capacity, 8);
1.340 - EXPECT_EQ(buf.size, 8);
1.341 - EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);
1.342 - cxBufferDestroy(&buf);
1.343 - EXPECT_TRUE(alloc.verify());
1.344 -}
1.345 -
1.346 -TEST(BufferMinimumCapacity, Extend) {
1.347 - CxTestingAllocator alloc;
1.348 - auto space = cxMalloc(&alloc, 8);
1.349 - CxBuffer buf;
1.350 - cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS); // NO auto extend!
1.351 - memcpy(space, "Testing", 8);
1.352 - buf.size = 8;
1.353 - cxBufferMinimumCapacity(&buf, 16);
1.354 - EXPECT_EQ(buf.capacity, 16);
1.355 - EXPECT_EQ(buf.size, 8);
1.356 - EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);
1.357 - cxBufferDestroy(&buf);
1.358 - EXPECT_TRUE(alloc.verify());
1.359 -}
1.360 -
1.361 -TEST(BufferClear, Test) {
1.362 - char space[16];
1.363 - strcpy(space, "clear test");
1.364 - CxBuffer buf;
1.365 - cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.366 - ASSERT_EQ(buf.size, 0);
1.367 - // only clear the used part of the buffer
1.368 - cxBufferClear(&buf);
1.369 - EXPECT_EQ(memcmp(space, "clear test", 10), 0);
1.370 - buf.size = 5;
1.371 - buf.pos = 3;
1.372 - cxBufferClear(&buf);
1.373 - EXPECT_EQ(memcmp(space, "\0\0\0\0\0 test", 10), 0);
1.374 - EXPECT_EQ(buf.size, 0);
1.375 - EXPECT_EQ(buf.pos, 0);
1.376 - cxBufferDestroy(&buf);
1.377 -}
1.378 -
1.379 -TEST(BufferReset, Test) {
1.380 - char space[16];
1.381 - strcpy(space, "reset test");
1.382 - CxBuffer buf;
1.383 - cxBufferInit(&buf, space, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.384 - buf.size = 5;
1.385 - buf.pos = 3;
1.386 - cxBufferReset(&buf);
1.387 - EXPECT_EQ(memcmp(space, "reset test", 10), 0);
1.388 - EXPECT_EQ(buf.size, 0);
1.389 - EXPECT_EQ(buf.pos, 0);
1.390 - cxBufferDestroy(&buf);
1.391 + CX_TEST_ASSERT(ret == 0);
1.392 + CX_TEST_ASSERT(buf.pos == 5);
1.393 + CX_TEST_ASSERT(buf.size == 6);
1.394 + CX_TEST_ASSERT(memcmp(buf.space, "tetest______", 8) == 0);
1.395 }
1.396
1.397 class BufferWrite : public ::testing::Test {
1.398 @@ -363,8 +199,8 @@
1.399 CxBuffer buf{}, target{};
1.400
1.401 void SetUp() override {
1.402 - cxBufferInit(&target, nullptr, 16, cxDefaultAllocator, CX_BUFFER_AUTO_EXTEND);
1.403 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.404 + cxBufferInit(&target, NULL, 16, cxDefaultAllocator, CX_BUFFER_AUTO_EXTEND);
1.405 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.406 buf.capacity = 8; // artificially reduce capacity to check OOB writes
1.407 memset(buf.space, 0, 16);
1.408 memcpy(buf.space, "prep", 4);
1.409 @@ -402,221 +238,221 @@
1.410
1.411 TEST_F(BufferWrite, SizeOneFit) {
1.412 const char *data = "test";
1.413 - ASSERT_EQ(buf.capacity, 8);
1.414 - ASSERT_EQ(buf.pos, 4);
1.415 - ASSERT_EQ(buf.size, 4);
1.416 + CX_TEST_ASSERT(buf.capacity == 8);
1.417 + CX_TEST_ASSERT(buf.pos == 4);
1.418 + CX_TEST_ASSERT(buf.size == 4);
1.419 size_t written = cxBufferWrite(data, 1, 4, &buf);
1.420 - EXPECT_EQ(written, 4);
1.421 - EXPECT_EQ(buf.size, 8);
1.422 - EXPECT_EQ(buf.pos, 8);
1.423 - EXPECT_EQ(buf.capacity, 8);
1.424 + CX_TEST_ASSERT(written == 4);
1.425 + CX_TEST_ASSERT(buf.size == 8);
1.426 + CX_TEST_ASSERT(buf.pos == 8);
1.427 + CX_TEST_ASSERT(buf.capacity == 8);
1.428 EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0);
1.429 }
1.430
1.431 TEST_F(BufferWrite, SizeOneDiscard) {
1.432 const char *data = "testing";
1.433 - ASSERT_EQ(buf.capacity, 8);
1.434 - ASSERT_EQ(buf.pos, 4);
1.435 - ASSERT_EQ(buf.size, 4);
1.436 + CX_TEST_ASSERT(buf.capacity == 8);
1.437 + CX_TEST_ASSERT(buf.pos == 4);
1.438 + CX_TEST_ASSERT(buf.size == 4);
1.439 size_t written = cxBufferWrite(data, 1, 7, &buf);
1.440 - EXPECT_EQ(written, 4);
1.441 - EXPECT_EQ(buf.size, 8);
1.442 - EXPECT_EQ(buf.pos, 8);
1.443 - EXPECT_EQ(buf.capacity, 8);
1.444 + CX_TEST_ASSERT(written == 4);
1.445 + CX_TEST_ASSERT(buf.size == 8);
1.446 + CX_TEST_ASSERT(buf.pos == 8);
1.447 + CX_TEST_ASSERT(buf.capacity == 8);
1.448 EXPECT_EQ(memcmp(buf.space, "preptest\0", 9), 0);
1.449 }
1.450
1.451 TEST_F(BufferWrite, SizeOneExtend) {
1.452 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.453 const char *data = "testing";
1.454 - ASSERT_EQ(buf.capacity, 8);
1.455 - ASSERT_EQ(buf.pos, 4);
1.456 - ASSERT_EQ(buf.size, 4);
1.457 + CX_TEST_ASSERT(buf.capacity == 8);
1.458 + CX_TEST_ASSERT(buf.pos == 4);
1.459 + CX_TEST_ASSERT(buf.size == 4);
1.460 size_t written = cxBufferWrite(data, 1, 7, &buf);
1.461 - EXPECT_EQ(written, 7);
1.462 - EXPECT_EQ(buf.size, 11);
1.463 - EXPECT_EQ(buf.pos, 11);
1.464 + CX_TEST_ASSERT(written == 7);
1.465 + CX_TEST_ASSERT(buf.size == 11);
1.466 + CX_TEST_ASSERT(buf.pos == 11);
1.467 EXPECT_GE(buf.capacity, 11);
1.468 EXPECT_EQ(memcmp(buf.space, "preptesting", 11), 0);
1.469 }
1.470
1.471 TEST_F(BufferWrite, MultibyteFit) {
1.472 const char *data = "test";
1.473 - ASSERT_EQ(buf.capacity, 8);
1.474 - ASSERT_EQ(buf.pos, 4);
1.475 - ASSERT_EQ(buf.size, 4);
1.476 + CX_TEST_ASSERT(buf.capacity == 8);
1.477 + CX_TEST_ASSERT(buf.pos == 4);
1.478 + CX_TEST_ASSERT(buf.size == 4);
1.479 size_t written = cxBufferWrite(data, 2, 2, &buf);
1.480 - EXPECT_EQ(written, 2);
1.481 - EXPECT_EQ(buf.size, 8);
1.482 - EXPECT_EQ(buf.pos, 8);
1.483 - EXPECT_EQ(buf.capacity, 8);
1.484 + CX_TEST_ASSERT(written == 2);
1.485 + CX_TEST_ASSERT(buf.size == 8);
1.486 + CX_TEST_ASSERT(buf.pos == 8);
1.487 + CX_TEST_ASSERT(buf.capacity == 8);
1.488 EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0);
1.489 }
1.490
1.491 TEST_F(BufferWrite, MultibyteDiscard) {
1.492 const char *data = "testing";
1.493 - ASSERT_EQ(buf.capacity, 8);
1.494 - ASSERT_EQ(buf.size, 4);
1.495 + CX_TEST_ASSERT(buf.capacity == 8);
1.496 + CX_TEST_ASSERT(buf.size == 4);
1.497 buf.pos = 3;
1.498 size_t written = cxBufferWrite(data, 2, 4, &buf);
1.499 // remember: whole elements are discarded if they do not fit
1.500 - EXPECT_EQ(written, 2);
1.501 - EXPECT_EQ(buf.size, 7);
1.502 - EXPECT_EQ(buf.pos, 7);
1.503 - EXPECT_EQ(buf.capacity, 8);
1.504 + CX_TEST_ASSERT(written == 2);
1.505 + CX_TEST_ASSERT(buf.size == 7);
1.506 + CX_TEST_ASSERT(buf.pos == 7);
1.507 + CX_TEST_ASSERT(buf.capacity == 8);
1.508 EXPECT_EQ(memcmp(buf.space, "pretest\0", 8), 0);
1.509 }
1.510
1.511 TEST_F(BufferWrite, MultibyteExtend) {
1.512 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.513 const char *data = "tester";
1.514 - ASSERT_EQ(buf.capacity, 8);
1.515 - ASSERT_EQ(buf.size, 4);
1.516 + CX_TEST_ASSERT(buf.capacity == 8);
1.517 + CX_TEST_ASSERT(buf.size == 4);
1.518 buf.pos = 3;
1.519 size_t written = cxBufferWrite(data, 2, 3, &buf);
1.520 // remember: whole elements are discarded if they do not fit
1.521 - EXPECT_EQ(written, 3);
1.522 - EXPECT_EQ(buf.size, 9);
1.523 - EXPECT_EQ(buf.pos, 9);
1.524 + CX_TEST_ASSERT(written == 3);
1.525 + CX_TEST_ASSERT(buf.size == 9);
1.526 + CX_TEST_ASSERT(buf.pos == 9);
1.527 EXPECT_GE(buf.capacity, 9);
1.528 EXPECT_EQ(memcmp(buf.space, "pretester", 9), 0);
1.529 }
1.530
1.531 TEST_F(BufferWrite, PutcWrapperFit) {
1.532 - ASSERT_EQ(buf.capacity, 8);
1.533 - ASSERT_EQ(buf.pos, 4);
1.534 - ASSERT_EQ(buf.size, 4);
1.535 + CX_TEST_ASSERT(buf.capacity == 8);
1.536 + CX_TEST_ASSERT(buf.pos == 4);
1.537 + CX_TEST_ASSERT(buf.size == 4);
1.538 int c = cxBufferPut(&buf, 0x200 | 'a');
1.539 - EXPECT_EQ(c, 'a');
1.540 - EXPECT_EQ(buf.size, 5);
1.541 - EXPECT_EQ(buf.pos, 5);
1.542 - EXPECT_EQ(buf.capacity, 8);
1.543 + CX_TEST_ASSERT(c == 'a');
1.544 + CX_TEST_ASSERT(buf.size == 5);
1.545 + CX_TEST_ASSERT(buf.pos == 5);
1.546 + CX_TEST_ASSERT(buf.capacity == 8);
1.547 EXPECT_EQ(memcmp(buf.space, "prepa\0", 6), 0);
1.548 }
1.549
1.550 TEST_F(BufferWrite, PutcWrapperDiscard) {
1.551 - ASSERT_EQ(buf.capacity, 8);
1.552 - ASSERT_EQ(buf.size, 4);
1.553 + CX_TEST_ASSERT(buf.capacity == 8);
1.554 + CX_TEST_ASSERT(buf.size == 4);
1.555 buf.pos = 8;
1.556 int c = cxBufferPut(&buf, 0x200 | 'a');
1.557 - EXPECT_EQ(c, EOF);
1.558 - EXPECT_EQ(buf.size, 4);
1.559 - EXPECT_EQ(buf.pos, 8);
1.560 - EXPECT_EQ(buf.capacity, 8);
1.561 + CX_TEST_ASSERT(c == EOF);
1.562 + CX_TEST_ASSERT(buf.size == 4);
1.563 + CX_TEST_ASSERT(buf.pos == 8);
1.564 + CX_TEST_ASSERT(buf.capacity == 8);
1.565 EXPECT_EQ(memcmp(buf.space, "prep\0\0\0\0\0", 9), 0);
1.566 }
1.567
1.568 TEST_F(BufferWrite, PutcWrapperExtend) {
1.569 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.570 - ASSERT_EQ(buf.capacity, 8);
1.571 - ASSERT_EQ(buf.size, 4);
1.572 + CX_TEST_ASSERT(buf.capacity == 8);
1.573 + CX_TEST_ASSERT(buf.size == 4);
1.574 buf.pos = 8;
1.575 int c = cxBufferPut(&buf, 0x200 | 'a');
1.576 - EXPECT_EQ(c, 'a');
1.577 - EXPECT_EQ(buf.size, 9);
1.578 - EXPECT_EQ(buf.pos, 9);
1.579 + CX_TEST_ASSERT(c == 'a');
1.580 + CX_TEST_ASSERT(buf.size == 9);
1.581 + CX_TEST_ASSERT(buf.pos == 9);
1.582 EXPECT_GE(buf.capacity, 9);
1.583 EXPECT_EQ(memcmp(buf.space, "prep\0\0\0\0a", 9), 0);
1.584 }
1.585
1.586 TEST_F(BufferWrite, PutStringWrapperFit) {
1.587 const char *data = "test";
1.588 - ASSERT_EQ(buf.capacity, 8);
1.589 - ASSERT_EQ(buf.pos, 4);
1.590 - ASSERT_EQ(buf.size, 4);
1.591 + CX_TEST_ASSERT(buf.capacity == 8);
1.592 + CX_TEST_ASSERT(buf.pos == 4);
1.593 + CX_TEST_ASSERT(buf.size == 4);
1.594 size_t written = cxBufferPutString(&buf, data);
1.595 - EXPECT_EQ(written, 4);
1.596 - EXPECT_EQ(buf.size, 8);
1.597 - EXPECT_EQ(buf.pos, 8);
1.598 - EXPECT_EQ(buf.capacity, 8);
1.599 + CX_TEST_ASSERT(written == 4);
1.600 + CX_TEST_ASSERT(buf.size == 8);
1.601 + CX_TEST_ASSERT(buf.pos == 8);
1.602 + CX_TEST_ASSERT(buf.capacity == 8);
1.603 EXPECT_EQ(memcmp(buf.space, "preptest", 8), 0);
1.604 }
1.605
1.606 TEST_F(BufferWrite, PutStringWrapperDiscard) {
1.607 const char *data = "testing";
1.608 - ASSERT_EQ(buf.capacity, 8);
1.609 - ASSERT_EQ(buf.pos, 4);
1.610 - ASSERT_EQ(buf.size, 4);
1.611 + CX_TEST_ASSERT(buf.capacity == 8);
1.612 + CX_TEST_ASSERT(buf.pos == 4);
1.613 + CX_TEST_ASSERT(buf.size == 4);
1.614 size_t written = cxBufferPutString(&buf, data);
1.615 - EXPECT_EQ(written, 4);
1.616 - EXPECT_EQ(buf.size, 8);
1.617 - EXPECT_EQ(buf.pos, 8);
1.618 - EXPECT_EQ(buf.capacity, 8);
1.619 + CX_TEST_ASSERT(written == 4);
1.620 + CX_TEST_ASSERT(buf.size == 8);
1.621 + CX_TEST_ASSERT(buf.pos == 8);
1.622 + CX_TEST_ASSERT(buf.capacity == 8);
1.623 EXPECT_EQ(memcmp(buf.space, "preptest\0", 9), 0);
1.624 }
1.625
1.626 TEST_F(BufferWrite, PutStringWrapperExtend) {
1.627 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.628 const char *data = "testing";
1.629 - ASSERT_EQ(buf.capacity, 8);
1.630 - ASSERT_EQ(buf.pos, 4);
1.631 - ASSERT_EQ(buf.size, 4);
1.632 + CX_TEST_ASSERT(buf.capacity == 8);
1.633 + CX_TEST_ASSERT(buf.pos == 4);
1.634 + CX_TEST_ASSERT(buf.size == 4);
1.635 size_t written = cxBufferPutString(&buf, data);
1.636 - EXPECT_EQ(written, 7);
1.637 - EXPECT_EQ(buf.size, 11);
1.638 - EXPECT_EQ(buf.pos, 11);
1.639 + CX_TEST_ASSERT(written == 7);
1.640 + CX_TEST_ASSERT(buf.size == 11);
1.641 + CX_TEST_ASSERT(buf.pos == 11);
1.642 EXPECT_GE(buf.capacity, 11);
1.643 EXPECT_EQ(memcmp(buf.space, "preptesting", 11), 0);
1.644 }
1.645
1.646 TEST_F(BufferWrite, MultOverflow) {
1.647 const char *data = "testing";
1.648 - ASSERT_EQ(buf.capacity, 8);
1.649 - ASSERT_EQ(buf.pos, 4);
1.650 - ASSERT_EQ(buf.size, 4);
1.651 + CX_TEST_ASSERT(buf.capacity == 8);
1.652 + CX_TEST_ASSERT(buf.pos == 4);
1.653 + CX_TEST_ASSERT(buf.size == 4);
1.654 size_t written = cxBufferWrite(data, 8, SIZE_MAX / 4, &buf);
1.655 - EXPECT_EQ(written, 0);
1.656 - EXPECT_EQ(buf.capacity, 8);
1.657 - EXPECT_EQ(buf.pos, 4);
1.658 - EXPECT_EQ(buf.size, 4);
1.659 + CX_TEST_ASSERT(written == 0);
1.660 + CX_TEST_ASSERT(buf.capacity == 8);
1.661 + CX_TEST_ASSERT(buf.pos == 4);
1.662 + CX_TEST_ASSERT(buf.size == 4);
1.663 EXPECT_EQ(memcmp(buf.space, "prep\0", 5), 0);
1.664 }
1.665
1.666 TEST_F(BufferWrite, MaxCapaOverflow) {
1.667 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.668 const char *data = "testing";
1.669 - ASSERT_EQ(buf.capacity, 8);
1.670 - ASSERT_EQ(buf.pos, 4);
1.671 - ASSERT_EQ(buf.size, 4);
1.672 + CX_TEST_ASSERT(buf.capacity == 8);
1.673 + CX_TEST_ASSERT(buf.pos == 4);
1.674 + CX_TEST_ASSERT(buf.size == 4);
1.675 size_t written = cxBufferWrite(data, 1, SIZE_MAX - 2, &buf);
1.676 - EXPECT_EQ(written, 0);
1.677 - EXPECT_EQ(buf.capacity, 8);
1.678 - EXPECT_EQ(buf.pos, 4);
1.679 - EXPECT_EQ(buf.size, 4);
1.680 + CX_TEST_ASSERT(written == 0);
1.681 + CX_TEST_ASSERT(buf.capacity == 8);
1.682 + CX_TEST_ASSERT(buf.pos == 4);
1.683 + CX_TEST_ASSERT(buf.size == 4);
1.684 EXPECT_EQ(memcmp(buf.space, "prep\0", 5), 0);
1.685 }
1.686
1.687 TEST_F(BufferWrite, OnlyOverwrite) {
1.688 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.689 - ASSERT_EQ(buf.capacity, 8);
1.690 + CX_TEST_ASSERT(buf.capacity == 8);
1.691 memcpy(buf.space, "preptest", 8);
1.692 buf.pos = 3;
1.693 buf.size = 8;
1.694 size_t written = cxBufferWrite("XXX", 2, 2, &buf);
1.695 - EXPECT_EQ(written, 2);
1.696 - EXPECT_EQ(buf.capacity, 8);
1.697 - EXPECT_EQ(buf.size, 8);
1.698 - EXPECT_EQ(buf.pos, 7);
1.699 + CX_TEST_ASSERT(written == 2);
1.700 + CX_TEST_ASSERT(buf.capacity == 8);
1.701 + CX_TEST_ASSERT(buf.size == 8);
1.702 + CX_TEST_ASSERT(buf.pos == 7);
1.703 EXPECT_EQ(memcmp(buf.space, "preXXX\0t", 8), 0);
1.704 }
1.705
1.706 TEST_F(BufferWrite, FlushAtCapacity) {
1.707 enableFlushing();
1.708 - ASSERT_EQ(buf.capacity, 8);
1.709 - ASSERT_EQ(buf.pos, 4);
1.710 + CX_TEST_ASSERT(buf.capacity == 8);
1.711 + CX_TEST_ASSERT(buf.pos == 4);
1.712 size_t written = cxBufferWrite("foo", 1, 3, &buf);
1.713 - EXPECT_EQ(written, 3);
1.714 - ASSERT_EQ(buf.pos, 7);
1.715 - ASSERT_EQ(buf.size, 7);
1.716 - ASSERT_EQ(target.pos, 0);
1.717 - ASSERT_EQ(target.size, 0);
1.718 + CX_TEST_ASSERT(written == 3);
1.719 + CX_TEST_ASSERT(buf.pos == 7);
1.720 + CX_TEST_ASSERT(buf.size == 7);
1.721 + CX_TEST_ASSERT(target.pos == 0);
1.722 + CX_TEST_ASSERT(target.size == 0);
1.723 written = cxBufferWrite("hello", 1, 5, &buf);
1.724 - EXPECT_EQ(written, 5);
1.725 - EXPECT_EQ(buf.pos, 0);
1.726 - EXPECT_EQ(buf.size, 0);
1.727 - EXPECT_EQ(buf.capacity, 8);
1.728 - EXPECT_EQ(target.pos, 12);
1.729 - ASSERT_EQ(target.size, 12);
1.730 + CX_TEST_ASSERT(written == 5);
1.731 + CX_TEST_ASSERT(buf.pos == 0);
1.732 + CX_TEST_ASSERT(buf.size == 0);
1.733 + CX_TEST_ASSERT(buf.capacity == 8);
1.734 + CX_TEST_ASSERT(target.pos == 12);
1.735 + CX_TEST_ASSERT(target.size == 12);
1.736 EXPECT_EQ(memcmp(target.space, "prepfoohello", 12), 0);
1.737 }
1.738
1.739 @@ -624,23 +460,23 @@
1.740 enableFlushing();
1.741 buf.flush_threshold = 12;
1.742 buf.flags |= CX_BUFFER_AUTO_EXTEND;
1.743 - ASSERT_EQ(buf.capacity, 8);
1.744 - ASSERT_EQ(buf.pos, 4);
1.745 + CX_TEST_ASSERT(buf.capacity == 8);
1.746 + CX_TEST_ASSERT(buf.pos == 4);
1.747 size_t written = cxBufferWrite("foobar", 1, 6, &buf);
1.748 - EXPECT_EQ(written, 6);
1.749 - ASSERT_EQ(buf.pos, 10);
1.750 - ASSERT_EQ(buf.size, 10);
1.751 + CX_TEST_ASSERT(written == 6);
1.752 + CX_TEST_ASSERT(buf.pos == 10);
1.753 + CX_TEST_ASSERT(buf.size == 10);
1.754 ASSERT_GE(buf.capacity, 10);
1.755 ASSERT_LE(buf.capacity, 12);
1.756 - ASSERT_EQ(target.pos, 0);
1.757 - ASSERT_EQ(target.size, 0);
1.758 + CX_TEST_ASSERT(target.pos == 0);
1.759 + CX_TEST_ASSERT(target.size == 0);
1.760 written = cxBufferWrite("hello", 1, 5, &buf);
1.761 - EXPECT_EQ(written, 5);
1.762 - EXPECT_EQ(buf.pos, 0);
1.763 - EXPECT_EQ(buf.size, 0);
1.764 + CX_TEST_ASSERT(written == 5);
1.765 + CX_TEST_ASSERT(buf.pos == 0);
1.766 + CX_TEST_ASSERT(buf.size == 0);
1.767 EXPECT_LE(buf.capacity, 12);
1.768 - EXPECT_EQ(target.pos, 15);
1.769 - ASSERT_EQ(target.size, 15);
1.770 + CX_TEST_ASSERT(target.pos == 15);
1.771 + CX_TEST_ASSERT(target.size == 15);
1.772 EXPECT_EQ(memcmp(target.space, "prepfoobarhello", 15), 0);
1.773 }
1.774
1.775 @@ -650,133 +486,43 @@
1.776 target.capacity = 16;
1.777 target.flags &= ~CX_BUFFER_AUTO_EXTEND;
1.778 buf.flush_func = (cx_write_func) mock_write_limited_rate;
1.779 - ASSERT_EQ(buf.capacity, 8);
1.780 - ASSERT_EQ(buf.pos, 4);
1.781 + CX_TEST_ASSERT(buf.capacity == 8);
1.782 + CX_TEST_ASSERT(buf.pos == 4);
1.783 size_t written = cxBufferWrite("foo", 1, 3, &buf);
1.784 - EXPECT_EQ(written, 3);
1.785 - ASSERT_EQ(buf.pos, 7);
1.786 - ASSERT_EQ(buf.size, 7);
1.787 - ASSERT_EQ(target.pos, 0);
1.788 - ASSERT_EQ(target.size, 0);
1.789 + CX_TEST_ASSERT(written == 3);
1.790 + CX_TEST_ASSERT(buf.pos == 7);
1.791 + CX_TEST_ASSERT(buf.size == 7);
1.792 + CX_TEST_ASSERT(target.pos == 0);
1.793 + CX_TEST_ASSERT(target.size == 0);
1.794 written = cxBufferWrite("hello, world!", 1, 13, &buf);
1.795 // " world!" fits into this buffer, the remaining stuff is flushed out
1.796 - EXPECT_EQ(written, 13);
1.797 - EXPECT_EQ(buf.pos, 7);
1.798 - EXPECT_EQ(buf.size, 7);
1.799 - EXPECT_EQ(buf.capacity, 8);
1.800 + CX_TEST_ASSERT(written == 13);
1.801 + CX_TEST_ASSERT(buf.pos == 7);
1.802 + CX_TEST_ASSERT(buf.size == 7);
1.803 + CX_TEST_ASSERT(buf.capacity == 8);
1.804 EXPECT_EQ(memcmp(buf.space, " world!", 7), 0);
1.805 - EXPECT_EQ(target.pos, 13);
1.806 - ASSERT_EQ(target.size, 13);
1.807 - EXPECT_EQ(target.capacity, 16);
1.808 + CX_TEST_ASSERT(target.pos == 13);
1.809 + CX_TEST_ASSERT(target.size == 13);
1.810 + CX_TEST_ASSERT(target.capacity == 16);
1.811 EXPECT_EQ(memcmp(target.space, "prepfoohello,", 13), 0);
1.812 }
1.813
1.814 -class BufferSeek : public BufferFixture {
1.815 -};
1.816 -
1.817 -TEST_F(BufferSeek, SetZero) {
1.818 - int result = cxBufferSeek(&buf, 0, SEEK_SET);
1.819 - EXPECT_EQ(result, 0);
1.820 - EXPECT_EQ(buf.pos, 0);
1.821 -}
1.822 -
1.823 -TEST_F(BufferSeek, SetValid) {
1.824 - int result = cxBufferSeek(&buf, 5, SEEK_SET);
1.825 - EXPECT_EQ(result, 0);
1.826 - EXPECT_EQ(buf.pos, 5);
1.827 -}
1.828 -
1.829 -TEST_F(BufferSeek, SetInvalid) {
1.830 - ASSERT_EQ(buf.pos, 3);
1.831 - int result = cxBufferSeek(&buf, 6, SEEK_SET);
1.832 - EXPECT_NE(result, 0);
1.833 - EXPECT_EQ(buf.pos, 3);
1.834 -}
1.835 -
1.836 -TEST_F(BufferSeek, CurZero) {
1.837 - ASSERT_EQ(buf.pos, 3);
1.838 - int result = cxBufferSeek(&buf, 0, SEEK_CUR);
1.839 - EXPECT_EQ(result, 0);
1.840 - EXPECT_EQ(buf.pos, 3);
1.841 -}
1.842 -
1.843 -TEST_F(BufferSeek, CurValidPositive) {
1.844 - ASSERT_EQ(buf.pos, 3);
1.845 - int result = cxBufferSeek(&buf, 2, SEEK_CUR);
1.846 - EXPECT_EQ(result, 0);
1.847 - EXPECT_EQ(buf.pos, 5);
1.848 -}
1.849 -
1.850 -TEST_F(BufferSeek, CurValidNegative) {
1.851 - ASSERT_EQ(buf.pos, 3);
1.852 - int result = cxBufferSeek(&buf, -3, SEEK_CUR);
1.853 - EXPECT_EQ(result, 0);
1.854 - EXPECT_EQ(buf.pos, 0);
1.855 -}
1.856 -
1.857 -TEST_F(BufferSeek, CurInvalidPositive) {
1.858 - ASSERT_EQ(buf.pos, 3);
1.859 - int result = cxBufferSeek(&buf, 3, SEEK_CUR);
1.860 - EXPECT_NE(result, 0);
1.861 - EXPECT_EQ(buf.pos, 3);
1.862 -}
1.863 -
1.864 -TEST_F(BufferSeek, CurInvalidNegative) {
1.865 - ASSERT_EQ(buf.pos, 3);
1.866 - int result = cxBufferSeek(&buf, -4, SEEK_CUR);
1.867 - EXPECT_NE(result, 0);
1.868 - EXPECT_EQ(buf.pos, 3);
1.869 -}
1.870 -
1.871 -TEST_F(BufferSeek, EndZero) {
1.872 - ASSERT_EQ(buf.size, 6);
1.873 - int result = cxBufferSeek(&buf, 0, SEEK_END);
1.874 - // the (past-the-)end position is always invalid
1.875 - EXPECT_NE(result, 0);
1.876 - EXPECT_EQ(buf.pos, 3);
1.877 -}
1.878 -
1.879 -TEST_F(BufferSeek, EndValid) {
1.880 - ASSERT_EQ(buf.size, 6);
1.881 - int result = cxBufferSeek(&buf, -6, SEEK_END);
1.882 - EXPECT_EQ(result, 0);
1.883 - EXPECT_EQ(buf.pos, 0);
1.884 -}
1.885 -
1.886 -TEST_F(BufferSeek, EndInvalid) {
1.887 - ASSERT_EQ(buf.size, 6);
1.888 - int result = cxBufferSeek(&buf, 1, SEEK_END);
1.889 - EXPECT_NE(result, 0);
1.890 - EXPECT_EQ(buf.pos, 3);
1.891 -}
1.892 -
1.893 -TEST_F(BufferSeek, WhenceInvalid) {
1.894 - ASSERT_EQ(buf.size, 6);
1.895 - ASSERT_EQ(buf.pos, 3);
1.896 - int result = cxBufferSeek(&buf, 2, 9000);
1.897 - EXPECT_NE(result, 0);
1.898 - EXPECT_EQ(buf.size, 6);
1.899 - EXPECT_EQ(buf.pos, 3);
1.900 -}
1.901 -
1.902 -class BufferEof : public BufferFixture {
1.903 -};
1.904
1.905 TEST_F(BufferEof, Reached) {
1.906 buf.pos = buf.size;
1.907 - EXPECT_TRUE(cxBufferEof(&buf));
1.908 + CX_TEST_ASSERT(cxBufferEof(&buf));
1.909 buf.pos = buf.size - 1;
1.910 - ASSERT_FALSE(cxBufferEof(&buf));
1.911 + CX_TEST_ASSERT(!cxBufferEof(&buf));
1.912 cxBufferPut(&buf, 'a');
1.913 - EXPECT_TRUE(cxBufferEof(&buf));
1.914 + CX_TEST_ASSERT(cxBufferEof(&buf));
1.915 }
1.916
1.917 TEST_F(BufferEof, NotReached) {
1.918 buf.pos = buf.size - 1;
1.919 - EXPECT_FALSE(cxBufferEof(&buf));
1.920 + CX_TEST_ASSERT(!cxBufferEof(&buf));
1.921 buf.pos = 0;
1.922 cxBufferWrite("test", 1, 5, &buf);
1.923 - EXPECT_FALSE(cxBufferEof(&buf));
1.924 + CX_TEST_ASSERT(!cxBufferEof(&buf));
1.925 }
1.926
1.927 class BufferRead : public ::testing::Test {
1.928 @@ -784,7 +530,7 @@
1.929 CxBuffer buf{};
1.930
1.931 void SetUp() override {
1.932 - cxBufferInit(&buf, nullptr, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.933 + cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
1.934 buf.capacity = 8; // artificially reduce capacity to check OOB writes
1.935 memset(buf.space, 0, 16);
1.936 memcpy(buf.space, "some data", 9);
1.937 @@ -802,7 +548,7 @@
1.938 EXPECT_EQ(cxBufferGet(&buf), 'e');
1.939 EXPECT_EQ(cxBufferGet(&buf), ' ');
1.940 EXPECT_EQ(cxBufferGet(&buf), 'd');
1.941 - EXPECT_EQ(buf.pos, 6);
1.942 + CX_TEST_ASSERT(buf.pos == 6);
1.943 }
1.944
1.945 TEST_F(BufferRead, GetEof) {
1.946 @@ -814,18 +560,18 @@
1.947 buf.pos = 2;
1.948 char target[4];
1.949 auto read = cxBufferRead(&target, 1, 4, &buf);
1.950 - ASSERT_EQ(read, 4);
1.951 + CX_TEST_ASSERT(read == 4);
1.952 EXPECT_EQ(memcmp(&target, "me d", 4), 0);
1.953 - EXPECT_EQ(buf.pos, 6);
1.954 + CX_TEST_ASSERT(buf.pos == 6);
1.955 }
1.956
1.957 TEST_F(BufferRead, ReadOutOfBounds) {
1.958 buf.pos = 6;
1.959 char target[4];
1.960 auto read = cxBufferRead(&target, 1, 4, &buf);
1.961 - ASSERT_EQ(read, 3);
1.962 + CX_TEST_ASSERT(read == 3);
1.963 EXPECT_EQ(memcmp(&target, "ata", 3), 0);
1.964 - EXPECT_EQ(buf.pos, 9);
1.965 + CX_TEST_ASSERT(buf.pos == 9);
1.966 }
1.967
1.968 TEST_F(BufferRead, ReadOutOfBoundsMultibyte) {
1.969 @@ -833,15 +579,15 @@
1.970 char target[4];
1.971 target[2] = '\0';
1.972 auto read = cxBufferRead(&target, 2, 2, &buf);
1.973 - ASSERT_EQ(read, 1);
1.974 + CX_TEST_ASSERT(read == 1);
1.975 EXPECT_EQ(memcmp(&target, "at\0", 3), 0);
1.976 - EXPECT_EQ(buf.pos, 8);
1.977 + CX_TEST_ASSERT(buf.pos == 8);
1.978 }
1.979
1.980 TEST_F(BufferRead, ReadEof) {
1.981 buf.pos = 9;
1.982 char target[4];
1.983 auto read = cxBufferRead(&target, 1, 1, &buf);
1.984 - ASSERT_EQ(read, 0);
1.985 - EXPECT_EQ(buf.pos, 9);
1.986 + CX_TEST_ASSERT(read == 0);
1.987 + CX_TEST_ASSERT(buf.pos == 9);
1.988 }
