diff --git a/include/util/tbuffer.inc b/include/util/tbuffer.inc index 7d24799115..deaa8e86a6 100644 --- a/include/util/tbuffer.inc +++ b/include/util/tbuffer.inc @@ -112,16 +112,14 @@ static FORCE_INLINE int32_t tBufferPutU64(SBufferWriter *writer, uint64_t value) return tBufferPutFixed(writer, &value, sizeof(value)); } -static FORCE_INLINE int32_t tBufferPutI16v(SBufferWriter *writer, int16_t value) { - return tBufferPutU16v(writer, ZIGZAGE(int16_t, value)); -} - -static FORCE_INLINE int32_t tBufferPutI32v(SBufferWriter *writer, int32_t value) { - return tBufferPutU32v(writer, ZIGZAGE(int32_t, value)); -} - -static FORCE_INLINE int32_t tBufferPutI64v(SBufferWriter *writer, int64_t value) { - return tBufferPutU64v(writer, ZIGZAGE(int64_t, value)); +static FORCE_INLINE int32_t tBufferPutU64v(SBufferWriter *writer, uint64_t value) { + int32_t code; + while (value >= 0x80) { + code = tBufferPutU8(writer, (value & 0x7F) | 0x80); + if (code) return code; + value >>= 7; + } + return tBufferPutU8(writer, value); } static FORCE_INLINE int32_t tBufferPutU16v(SBufferWriter *writer, uint16_t value) { @@ -132,13 +130,16 @@ static FORCE_INLINE int32_t tBufferPutU32v(SBufferWriter *writer, uint32_t value return tBufferPutU64v(writer, value); } -static FORCE_INLINE int32_t tBufferPutU64v(SBufferWriter *writer, uint64_t value) { - int32_t code; - while (value < 0x80) { - code = tBufferPutU8(writer, (value & 0x7F) | 0x80); - if (code) return code; - } - return tBufferPutU8(writer, value); +static FORCE_INLINE int32_t tBufferPutI16v(SBufferWriter *writer, int16_t value) { + return tBufferPutU16v(writer, ZIGZAGE(int16_t, value)); +} + +static FORCE_INLINE int32_t tBufferPutI32v(SBufferWriter *writer, int32_t value) { + return tBufferPutU32v(writer, ZIGZAGE(int32_t, value)); +} + +static FORCE_INLINE int32_t tBufferPutI64v(SBufferWriter *writer, int64_t value) { + return tBufferPutU64v(writer, ZIGZAGE(int64_t, value)); } static FORCE_INLINE int32_t tBufferPutBinary(SBufferWriter *writer, const void *data, uint32_t size) { @@ -218,33 +219,27 @@ static int32_t tBufferGetU64(SBufferReader *reader, uint64_t *value) { return tBufferGetFixed(reader, value, sizeof(*value)); } -static int32_t tBufferGetI16v(SBufferReader *reader, int16_t *value) { - uint16_t u16; - int32_t code = tBufferGetU16v(reader, &u16); - if (code) return code; - if (value) { - *value = ZIGZAGE(int16_t, u16); - } - return 0; -} +static int32_t tBufferGetU64v(SBufferReader *reader, uint64_t *value) { + uint8_t byte; + int32_t code; -static int32_t tBufferGetI32v(SBufferReader *reader, int32_t *value) { - uint32_t u32; - int32_t code = tBufferGetU32v(reader, &u32); - if (code) return code; if (value) { - *value = ZIGZAGE(int32_t, u32); + *value = 0; } - return 0; -} -static int32_t tBufferGetI64v(SBufferReader *reader, int64_t *value) { - uint64_t u64; - int32_t code = tBufferGetU64v(reader, &u64); - if (code) return code; - if (value) { - *value = ZIGZAGE(int64_t, u64); + for (int32_t i = 0;; i++) { + code = tBufferGetU8(reader, &byte); + if (code) return code; + + if (value) { + *value |= ((uint64_t)(byte & 0x7F)) << (i * 7); + } + + if (byte < 0x80) { + break; + } } + return 0; } @@ -268,27 +263,33 @@ static int32_t tBufferGetU32v(SBufferReader *reader, uint32_t *value) { return 0; } -static int32_t tBufferGetU64v(SBufferReader *reader, uint64_t *value) { - uint8_t byte; - int32_t code; - +static int32_t tBufferGetI16v(SBufferReader *reader, int16_t *value) { + uint16_t u16; + int32_t code = tBufferGetU16v(reader, &u16); + if (code) return code; if (value) { - *value = 0; + *value = ZIGZAGD(int16_t, u16); } + return 0; +} - for (;;) { - code = tBufferGetU8(reader, &byte); - if (code) return code; - - if (value) { - *value = (uint64_t)((byte & 0x7F) | (*value << 7)); - } - - if (byte < 0x80) { - break; - } +static int32_t tBufferGetI32v(SBufferReader *reader, int32_t *value) { + uint32_t u32; + int32_t code = tBufferGetU32v(reader, &u32); + if (code) return code; + if (value) { + *value = ZIGZAGD(int32_t, u32); } + return 0; +} +static int32_t tBufferGetI64v(SBufferReader *reader, int64_t *value) { + uint64_t u64; + int32_t code = tBufferGetU64v(reader, &u64); + if (code) return code; + if (value) { + *value = ZIGZAGD(int64_t, u64); + } return 0; } diff --git a/source/util/test/CMakeLists.txt b/source/util/test/CMakeLists.txt index f4f3880388..65eac9c090 100644 --- a/source/util/test/CMakeLists.txt +++ b/source/util/test/CMakeLists.txt @@ -100,3 +100,11 @@ add_test( NAME talgoTest COMMAND talgoTest ) + +# bufferTest +add_executable(bufferTest "bufferTest.cpp") +target_link_libraries(bufferTest os util gtest_main) +add_test( + NAME bufferTest + COMMAND bufferTest +) \ No newline at end of file diff --git a/source/util/test/bufferTest.cpp b/source/util/test/bufferTest.cpp new file mode 100644 index 0000000000..043f0716ab --- /dev/null +++ b/source/util/test/bufferTest.cpp @@ -0,0 +1,724 @@ +#include + +#include "tbuffer.h" + +typedef struct { + int8_t value1; + int32_t value2; + int64_t value3; +} STestStruct; + +TEST(BufferTest, simpleTest1) { + SBuffer buffer = tBufferInit(); + + GTEST_ASSERT_EQ(tBufferGetSize(&buffer), 0); + GTEST_ASSERT_EQ(tBufferGetData(&buffer), nullptr); + + tBufferDestroy(&buffer); +} + +TEST(BufferTest, forwardWriteAndRead) { + int32_t code = 0; + bool forward = true; + SBuffer buffer = tBufferInit(); + taosSeedRand(taosGetTimestampSec()); + + // write + SBufferWriter writer = tBufferWriterInit(forward, tBufferGetSize(&buffer), &buffer); + + /* fix-len struct */ + STestStruct testStruct = {1, 2}; + GTEST_ASSERT_EQ(tBufferPutFixed(&writer, &testStruct, sizeof(STestStruct)), 0); + + /* int8_t */ + int8_t i8 = taosRand() % UINT8_MAX - INT8_MAX; + GTEST_ASSERT_EQ(tBufferPutI8(&writer, i8), 0); + + /* int16_t */ + int8_t i16 = taosRand() % UINT16_MAX - INT16_MAX; + GTEST_ASSERT_EQ(tBufferPutI16(&writer, i16), 0); + + /* int32_t */ + int8_t i32 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutI32(&writer, i32), 0); + + /* int64_t */ + int64_t i64 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutI64(&writer, i64), 0); + + /* uint8_t */ + uint8_t u8 = taosRand() % UINT8_MAX; + GTEST_ASSERT_EQ(tBufferPutU8(&writer, u8), 0); + + /* uint16_t */ + uint16_t u16 = taosRand() % UINT16_MAX; + GTEST_ASSERT_EQ(tBufferPutU16(&writer, u16), 0); + + /* uint32_t */ + uint32_t u32 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutU32(&writer, u32), 0); + + /* uint64_t */ + uint64_t u64 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutU64(&writer, u64), 0); + + /* float */ + float f = (float)taosRand() / (float)taosRand(); + GTEST_ASSERT_EQ(tBufferPutF32(&writer, f), 0); + + /* double */ + double d = (double)taosRand() / (double)taosRand(); + GTEST_ASSERT_EQ(tBufferPutF64(&writer, d), 0); + + /* binary */ + uint8_t binary[10]; + for (int32_t i = 0; i < sizeof(binary); ++i) { + binary[i] = taosRand() % UINT8_MAX; + } + GTEST_ASSERT_EQ(tBufferPutBinary(&writer, binary, sizeof(binary)), 0); + + /* cstr */ + const char *cstr = "hello world"; + GTEST_ASSERT_EQ(tBufferPutCStr(&writer, cstr), 0); + + /* uint16v_t */ + uint16_t u16v[] = {0, 127, 128, 129, 16384, 16385, 16386, UINT16_MAX}; + for (int32_t i = 0; i < sizeof(u16v) / sizeof(u16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutU16v(&writer, u16v[i]), 0); + } + + /* uint32v_t */ + uint32_t u32v[] = {0, 127, 128, 129, 16384, 16385, 16386, (1 << 21) - 1, + (1 << 21), (1 << 21) + 1, (1 << 28) - 1, (1 << 28), (1 << 28) + 1, UINT32_MAX}; + for (int32_t i = 0; i < sizeof(u32v) / sizeof(u32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutU32v(&writer, u32v[i]), 0); + } + + /* uint64v_t */ + uint64_t u64v[] = {0, // 0 + (1ul << (7 * 1)) - 1, + (1ul << (7 * 1)), + (1ul << (7 * 1)) + 1, + (1ul << (7 * 2)) - 1, + (1ul << (7 * 2)), + (1ul << (7 * 2)) + 1, + (1ul << (7 * 3)) - 1, + (1ul << (7 * 3)), + (1ul << (7 * 3)) + 1, + (1ul << (7 * 4)) - 1, + (1ul << (7 * 4)), + (1ul << (7 * 4)) + 1, + (1ul << (7 * 5)) - 1, + (1ul << (7 * 5)), + (1ul << (7 * 5)) + 1, + (1ul << (7 * 6)) - 1, + (1ul << (7 * 6)), + (1ul << (7 * 6)) + 1, + (1ul << (7 * 7)) - 1, + (1ul << (7 * 7)), + (1ul << (7 * 7)) + 1, + (1ul << (7 * 8)) - 1, + (1ul << (7 * 8)), + (1ul << (7 * 8)) + 1, + (1ul << (7 * 9)) - 1, + (1ul << (7 * 9)), + (1ul << (7 * 9)) + 1, + UINT64_MAX}; + for (int32_t i = 0; i < sizeof(u64v) / sizeof(u64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutU64v(&writer, u64v[i]), 0); + } + + /* int16v_t */ + int16_t i16v[] = { + INT16_MIN, // + -((1 << (7 * 1)) - 1), + -((1 << (7 * 1))), + -((1 << (7 * 1)) + 1), + -((1 << (7 * 2)) - 1), + -((1 << (7 * 2))), + -((1 << (7 * 2)) + 1), + (1 << (7 * 0)) - 1, + (1 << (7 * 0)), + (1 << (7 * 0)) + 1, + (1 << (7 * 1)) - 1, + (1 << (7 * 1)), + (1 << (7 * 1)) + 1, + (1 << (7 * 2)) - 1, + (1 << (7 * 2)), + (1 << (7 * 2)) + 1, + INT16_MAX, + }; + for (int32_t i = 0; i < sizeof(i16v) / sizeof(i16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutI16v(&writer, i16v[i]), 0); + } + + /* int32v_t */ + int32_t i32v[] = { + INT32_MIN, // + -((1 << (7 * 1)) - 1), + -((1 << (7 * 1))), + -((1 << (7 * 1)) + 1), + -((1 << (7 * 2)) - 1), + -((1 << (7 * 2))), + -((1 << (7 * 2)) + 1), + -((1 << (7 * 3)) - 1), + -((1 << (7 * 3))), + -((1 << (7 * 3)) + 1), + -((1 << (7 * 4)) - 1), + -((1 << (7 * 4))), + -((1 << (7 * 4)) + 1), + (1 << (7 * 0)) - 1, + (1 << (7 * 0)), + (1 << (7 * 0)) + 1, + (1 << (7 * 1)) - 1, + (1 << (7 * 1)), + (1 << (7 * 1)) + 1, + (1 << (7 * 2)) - 1, + (1 << (7 * 2)), + (1 << (7 * 2)) + 1, + (1 << (7 * 3)) - 1, + (1 << (7 * 3)), + (1 << (7 * 3)) + 1, + (1 << (7 * 4)) - 1, + (1 << (7 * 4)), + (1 << (7 * 4)) + 1, + INT32_MAX, + }; + for (int32_t i = 0; i < sizeof(i32v) / sizeof(i32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutI32v(&writer, i32v[i]), 0); + } + + /* int64v_t */ + int64_t i64v[] = { + INT64_MIN, // + -((1l << (7 * 1)) - 1), + -((1l << (7 * 1))), + -((1l << (7 * 1)) + 1), + -((1l << (7 * 2)) - 1), + -((1l << (7 * 2))), + -((1l << (7 * 2)) + 1), + -((1l << (7 * 3)) - 1), + -((1l << (7 * 3))), + -((1l << (7 * 3)) + 1), + -((1l << (7 * 4)) - 1), + -((1l << (7 * 4))), + -((1l << (7 * 4)) + 1), + -((1l << (7 * 5)) - 1), + -((1l << (7 * 5))), + -((1l << (7 * 5)) + 1), + -((1l << (7 * 6)) - 1), + -((1l << (7 * 6))), + -((1l << (7 * 6)) + 1), + -((1l << (7 * 7)) - 1), + -((1l << (7 * 7))), + -((1l << (7 * 7)) + 1), + -((1l << (7 * 8)) - 1), + -((1l << (7 * 8))), + -((1l << (7 * 8)) + 1), + -((1l << (7 * 9)) + 1), + ((1l << (7 * 1)) - 1), + ((1l << (7 * 1))), + ((1l << (7 * 1)) + 1), + ((1l << (7 * 2)) - 1), + ((1l << (7 * 2))), + ((1l << (7 * 2)) + 1), + ((1l << (7 * 3)) - 1), + ((1l << (7 * 3))), + ((1l << (7 * 3)) + 1), + ((1l << (7 * 4)) - 1), + ((1l << (7 * 4))), + ((1l << (7 * 4)) + 1), + ((1l << (7 * 5)) - 1), + ((1l << (7 * 5))), + ((1l << (7 * 5)) + 1), + ((1l << (7 * 6)) - 1), + ((1l << (7 * 6))), + ((1l << (7 * 6)) + 1), + ((1l << (7 * 7)) - 1), + ((1l << (7 * 7))), + ((1l << (7 * 7)) + 1), + ((1l << (7 * 8)) - 1), + ((1l << (7 * 8))), + ((1l << (7 * 8)) + 1), + ((1l << (7 * 9)) + 1), + INT64_MAX, + }; + for (int32_t i = 0; i < sizeof(i64v) / sizeof(i64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutI64v(&writer, i64v[i]), 0); + } + + tBufferWriterDestroy(&writer); + + // read + SBufferReader reader = tBufferReaderInit(forward, 0, &buffer); + + /* fix-len struct */ + STestStruct testStruct2 = {1, 2}; + GTEST_ASSERT_EQ(tBufferGetFixed(&reader, &testStruct2, sizeof(STestStruct)), 0); + GTEST_ASSERT_EQ(testStruct.value1, testStruct2.value1); + GTEST_ASSERT_EQ(testStruct.value2, testStruct2.value2); + GTEST_ASSERT_EQ(testStruct.value3, testStruct2.value3); + + /* int8_t */ + int8_t i8_2 = 97; + GTEST_ASSERT_EQ(tBufferGetI8(&reader, &i8_2), 0); + GTEST_ASSERT_EQ(i8, i8_2); + + /* int16_t */ + int16_t i16_2; + GTEST_ASSERT_EQ(tBufferGetI16(&reader, &i16_2), 0); + GTEST_ASSERT_EQ(i16, i16_2); + + /* int32_t */ + int32_t i32_2; + GTEST_ASSERT_EQ(tBufferGetI32(&reader, &i32_2), 0); + GTEST_ASSERT_EQ(i32, i32_2); + + /* int64_t */ + int64_t i64_2; + GTEST_ASSERT_EQ(tBufferGetI64(&reader, &i64_2), 0); + GTEST_ASSERT_EQ(i64, i64_2); + + /* uint8_t */ + uint8_t u8_2; + GTEST_ASSERT_EQ(tBufferGetU8(&reader, &u8_2), 0); + GTEST_ASSERT_EQ(u8, u8_2); + + /* uint16_t */ + uint16_t u16_2; + GTEST_ASSERT_EQ(tBufferGetU16(&reader, &u16_2), 0); + GTEST_ASSERT_EQ(u16, u16_2); + + /* uint32_t */ + uint32_t u32_2; + GTEST_ASSERT_EQ(tBufferGetU32(&reader, &u32_2), 0); + GTEST_ASSERT_EQ(u32, u32_2); + + /* uint64_t */ + uint64_t u64_2; + GTEST_ASSERT_EQ(tBufferGetU64(&reader, &u64_2), 0); + GTEST_ASSERT_EQ(u64, u64_2); + + /* float */ + float f_2; + GTEST_ASSERT_EQ(tBufferGetF32(&reader, &f_2), 0); + GTEST_ASSERT_EQ(f, f_2); + + /* double */ + double d_2; + GTEST_ASSERT_EQ(tBufferGetF64(&reader, &d_2), 0); + GTEST_ASSERT_EQ(d, d_2); + + /* binary */ + const void *binary2; + uint32_t binarySize; + GTEST_ASSERT_EQ(tBufferGetBinary(&reader, &binary2, &binarySize), 0); + GTEST_ASSERT_EQ(memcmp(binary, binary2, sizeof(binary)), 0); + GTEST_ASSERT_EQ(binarySize, sizeof(binary)); + + /* cstr */ + const char *cstr2; + GTEST_ASSERT_EQ(tBufferGetCStr(&reader, &cstr2), 0); + GTEST_ASSERT_EQ(strcmp(cstr, cstr2), 0); + + /* uint16v_t */ + uint16_t u16v2[sizeof(u16v) / sizeof(u16v[0])]; + for (int32_t i = 0; i < sizeof(u16v) / sizeof(u16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetU16v(&reader, &u16v2[i]), 0); + GTEST_ASSERT_EQ(u16v[i], u16v2[i]); + } + + /* uint32v_t */ + uint32_t u32v2[sizeof(u32v) / sizeof(u32v[0])]; + for (int32_t i = 0; i < sizeof(u32v) / sizeof(u32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetU32v(&reader, &u32v2[i]), 0); + GTEST_ASSERT_EQ(u32v[i], u32v2[i]); + } + + /* uint64v_t */ + uint64_t u64v2[sizeof(u64v) / sizeof(u64v[0])]; + for (int32_t i = 0; i < sizeof(u64v) / sizeof(u64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetU64v(&reader, &u64v2[i]), 0); + GTEST_ASSERT_EQ(u64v[i], u64v2[i]); + } + + /* int16v_t */ + int16_t i16v2[sizeof(i16v) / sizeof(i16v[0])]; + for (int32_t i = 0; i < sizeof(i16v) / sizeof(i16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetI16v(&reader, &i16v2[i]), 0); + GTEST_ASSERT_EQ(i16v[i], i16v2[i]); + } + + /* int32v_t */ + int32_t i32v2[sizeof(i32v) / sizeof(i32v[0])]; + for (int32_t i = 0; i < sizeof(i32v) / sizeof(i32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetI32v(&reader, &i32v2[i]), 0); + GTEST_ASSERT_EQ(i32v[i], i32v2[i]); + } + + /* int64v_t */ + int64_t i64v2[sizeof(i64v) / sizeof(i64v[0])]; + for (int32_t i = 0; i < sizeof(i64v) / sizeof(i64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetI64v(&reader, &i64v2[i]), 0); + GTEST_ASSERT_EQ(i64v[i], i64v2[i]); + } + + tBufferReaderDestroy(&reader); + + // clear + tBufferDestroy(&buffer); +} + +TEST(BufferTest, backwardWriteAndRead) { + int32_t code = 0; + bool forward = false; + SBuffer buffer = tBufferInit(); + taosSeedRand(taosGetTimestampSec()); + + // write + SBufferWriter writer = tBufferWriterInit(forward, 4096, &buffer); + + /* fix-len struct */ + STestStruct testStruct = {1, 2}; + GTEST_ASSERT_EQ(tBufferPutFixed(&writer, &testStruct, sizeof(STestStruct)), 0); + + /* int8_t */ + int8_t i8 = taosRand() % UINT8_MAX - INT8_MAX; + GTEST_ASSERT_EQ(tBufferPutI8(&writer, i8), 0); + + /* int16_t */ + int8_t i16 = taosRand() % UINT16_MAX - INT16_MAX; + GTEST_ASSERT_EQ(tBufferPutI16(&writer, i16), 0); + + /* int32_t */ + int8_t i32 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutI32(&writer, i32), 0); + + /* int64_t */ + int64_t i64 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutI64(&writer, i64), 0); + + /* uint8_t */ + uint8_t u8 = taosRand() % UINT8_MAX; + GTEST_ASSERT_EQ(tBufferPutU8(&writer, u8), 0); + + /* uint16_t */ + uint16_t u16 = taosRand() % UINT16_MAX; + GTEST_ASSERT_EQ(tBufferPutU16(&writer, u16), 0); + + /* uint32_t */ + uint32_t u32 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutU32(&writer, u32), 0); + + /* uint64_t */ + uint64_t u64 = taosRand(); + GTEST_ASSERT_EQ(tBufferPutU64(&writer, u64), 0); + + /* float */ + float f = (float)taosRand() / (float)taosRand(); + GTEST_ASSERT_EQ(tBufferPutF32(&writer, f), 0); + + /* double */ + double d = (double)taosRand() / (double)taosRand(); + GTEST_ASSERT_EQ(tBufferPutF64(&writer, d), 0); + + /* binary */ + uint8_t binary[10]; + for (int32_t i = 0; i < sizeof(binary); ++i) { + binary[i] = taosRand() % UINT8_MAX; + } + GTEST_ASSERT_EQ(tBufferPutBinary(&writer, binary, sizeof(binary)), 0); + + /* cstr */ + const char *cstr = "hello world"; + GTEST_ASSERT_EQ(tBufferPutCStr(&writer, cstr), 0); + + /* uint16v_t */ + uint16_t u16v[] = {0, 127, 128, 129, 16384, 16385, 16386, UINT16_MAX}; + for (int32_t i = 0; i < sizeof(u16v) / sizeof(u16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutU16v(&writer, u16v[i]), 0); + } + + /* uint32v_t */ + uint32_t u32v[] = {0, 127, 128, 129, 16384, 16385, 16386, (1 << 21) - 1, + (1 << 21), (1 << 21) + 1, (1 << 28) - 1, (1 << 28), (1 << 28) + 1, UINT32_MAX}; + for (int32_t i = 0; i < sizeof(u32v) / sizeof(u32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutU32v(&writer, u32v[i]), 0); + } + + /* uint64v_t */ + uint64_t u64v[] = {0, // 0 + (1ul << (7 * 1)) - 1, + (1ul << (7 * 1)), + (1ul << (7 * 1)) + 1, + (1ul << (7 * 2)) - 1, + (1ul << (7 * 2)), + (1ul << (7 * 2)) + 1, + (1ul << (7 * 3)) - 1, + (1ul << (7 * 3)), + (1ul << (7 * 3)) + 1, + (1ul << (7 * 4)) - 1, + (1ul << (7 * 4)), + (1ul << (7 * 4)) + 1, + (1ul << (7 * 5)) - 1, + (1ul << (7 * 5)), + (1ul << (7 * 5)) + 1, + (1ul << (7 * 6)) - 1, + (1ul << (7 * 6)), + (1ul << (7 * 6)) + 1, + (1ul << (7 * 7)) - 1, + (1ul << (7 * 7)), + (1ul << (7 * 7)) + 1, + (1ul << (7 * 8)) - 1, + (1ul << (7 * 8)), + (1ul << (7 * 8)) + 1, + (1ul << (7 * 9)) - 1, + (1ul << (7 * 9)), + (1ul << (7 * 9)) + 1, + UINT64_MAX}; + for (int32_t i = 0; i < sizeof(u64v) / sizeof(u64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutU64v(&writer, u64v[i]), 0); + } + + /* int16v_t */ + int16_t i16v[] = { + INT16_MIN, // + -((1 << (7 * 1)) - 1), + -((1 << (7 * 1))), + -((1 << (7 * 1)) + 1), + -((1 << (7 * 2)) - 1), + -((1 << (7 * 2))), + -((1 << (7 * 2)) + 1), + (1 << (7 * 0)) - 1, + (1 << (7 * 0)), + (1 << (7 * 0)) + 1, + (1 << (7 * 1)) - 1, + (1 << (7 * 1)), + (1 << (7 * 1)) + 1, + (1 << (7 * 2)) - 1, + (1 << (7 * 2)), + (1 << (7 * 2)) + 1, + INT16_MAX, + }; + for (int32_t i = 0; i < sizeof(i16v) / sizeof(i16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutI16v(&writer, i16v[i]), 0); + } + + /* int32v_t */ + int32_t i32v[] = { + INT32_MIN, // + -((1 << (7 * 1)) - 1), + -((1 << (7 * 1))), + -((1 << (7 * 1)) + 1), + -((1 << (7 * 2)) - 1), + -((1 << (7 * 2))), + -((1 << (7 * 2)) + 1), + -((1 << (7 * 3)) - 1), + -((1 << (7 * 3))), + -((1 << (7 * 3)) + 1), + -((1 << (7 * 4)) - 1), + -((1 << (7 * 4))), + -((1 << (7 * 4)) + 1), + (1 << (7 * 0)) - 1, + (1 << (7 * 0)), + (1 << (7 * 0)) + 1, + (1 << (7 * 1)) - 1, + (1 << (7 * 1)), + (1 << (7 * 1)) + 1, + (1 << (7 * 2)) - 1, + (1 << (7 * 2)), + (1 << (7 * 2)) + 1, + (1 << (7 * 3)) - 1, + (1 << (7 * 3)), + (1 << (7 * 3)) + 1, + (1 << (7 * 4)) - 1, + (1 << (7 * 4)), + (1 << (7 * 4)) + 1, + INT32_MAX, + }; + for (int32_t i = 0; i < sizeof(i32v) / sizeof(i32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutI32v(&writer, i32v[i]), 0); + } + + /* int64v_t */ + int64_t i64v[] = { + INT64_MIN, // + -((1l << (7 * 1)) - 1), + -((1l << (7 * 1))), + -((1l << (7 * 1)) + 1), + -((1l << (7 * 2)) - 1), + -((1l << (7 * 2))), + -((1l << (7 * 2)) + 1), + -((1l << (7 * 3)) - 1), + -((1l << (7 * 3))), + -((1l << (7 * 3)) + 1), + -((1l << (7 * 4)) - 1), + -((1l << (7 * 4))), + -((1l << (7 * 4)) + 1), + -((1l << (7 * 5)) - 1), + -((1l << (7 * 5))), + -((1l << (7 * 5)) + 1), + -((1l << (7 * 6)) - 1), + -((1l << (7 * 6))), + -((1l << (7 * 6)) + 1), + -((1l << (7 * 7)) - 1), + -((1l << (7 * 7))), + -((1l << (7 * 7)) + 1), + -((1l << (7 * 8)) - 1), + -((1l << (7 * 8))), + -((1l << (7 * 8)) + 1), + -((1l << (7 * 9)) + 1), + ((1l << (7 * 1)) - 1), + ((1l << (7 * 1))), + ((1l << (7 * 1)) + 1), + ((1l << (7 * 2)) - 1), + ((1l << (7 * 2))), + ((1l << (7 * 2)) + 1), + ((1l << (7 * 3)) - 1), + ((1l << (7 * 3))), + ((1l << (7 * 3)) + 1), + ((1l << (7 * 4)) - 1), + ((1l << (7 * 4))), + ((1l << (7 * 4)) + 1), + ((1l << (7 * 5)) - 1), + ((1l << (7 * 5))), + ((1l << (7 * 5)) + 1), + ((1l << (7 * 6)) - 1), + ((1l << (7 * 6))), + ((1l << (7 * 6)) + 1), + ((1l << (7 * 7)) - 1), + ((1l << (7 * 7))), + ((1l << (7 * 7)) + 1), + ((1l << (7 * 8)) - 1), + ((1l << (7 * 8))), + ((1l << (7 * 8)) + 1), + ((1l << (7 * 9)) + 1), + INT64_MAX, + }; + for (int32_t i = 0; i < sizeof(i64v) / sizeof(i64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferPutI64v(&writer, i64v[i]), 0); + } + + tBufferWriterDestroy(&writer); + + // read + SBufferReader reader = tBufferReaderInit(forward, 4096, &buffer); + + /* fix-len struct */ + STestStruct testStruct2 = {1, 2}; + GTEST_ASSERT_EQ(tBufferGetFixed(&reader, &testStruct2, sizeof(STestStruct)), 0); + GTEST_ASSERT_EQ(testStruct.value1, testStruct2.value1); + GTEST_ASSERT_EQ(testStruct.value2, testStruct2.value2); + GTEST_ASSERT_EQ(testStruct.value3, testStruct2.value3); + + /* int8_t */ + int8_t i8_2 = 97; + GTEST_ASSERT_EQ(tBufferGetI8(&reader, &i8_2), 0); + GTEST_ASSERT_EQ(i8, i8_2); + + /* int16_t */ + int16_t i16_2; + GTEST_ASSERT_EQ(tBufferGetI16(&reader, &i16_2), 0); + GTEST_ASSERT_EQ(i16, i16_2); + + /* int32_t */ + int32_t i32_2; + GTEST_ASSERT_EQ(tBufferGetI32(&reader, &i32_2), 0); + GTEST_ASSERT_EQ(i32, i32_2); + + /* int64_t */ + int64_t i64_2; + GTEST_ASSERT_EQ(tBufferGetI64(&reader, &i64_2), 0); + GTEST_ASSERT_EQ(i64, i64_2); + + /* uint8_t */ + uint8_t u8_2; + GTEST_ASSERT_EQ(tBufferGetU8(&reader, &u8_2), 0); + GTEST_ASSERT_EQ(u8, u8_2); + + /* uint16_t */ + uint16_t u16_2; + GTEST_ASSERT_EQ(tBufferGetU16(&reader, &u16_2), 0); + GTEST_ASSERT_EQ(u16, u16_2); + + /* uint32_t */ + uint32_t u32_2; + GTEST_ASSERT_EQ(tBufferGetU32(&reader, &u32_2), 0); + GTEST_ASSERT_EQ(u32, u32_2); + + /* uint64_t */ + uint64_t u64_2; + GTEST_ASSERT_EQ(tBufferGetU64(&reader, &u64_2), 0); + GTEST_ASSERT_EQ(u64, u64_2); + + /* float */ + float f_2; + GTEST_ASSERT_EQ(tBufferGetF32(&reader, &f_2), 0); + GTEST_ASSERT_EQ(f, f_2); + + /* double */ + double d_2; + GTEST_ASSERT_EQ(tBufferGetF64(&reader, &d_2), 0); + GTEST_ASSERT_EQ(d, d_2); + + /* binary */ + const void *binary2; + uint32_t binarySize; + GTEST_ASSERT_EQ(tBufferGetBinary(&reader, &binary2, &binarySize), 0); + GTEST_ASSERT_EQ(memcmp(binary, binary2, sizeof(binary)), 0); + GTEST_ASSERT_EQ(binarySize, sizeof(binary)); + + /* cstr */ + const char *cstr2; + GTEST_ASSERT_EQ(tBufferGetCStr(&reader, &cstr2), 0); + GTEST_ASSERT_EQ(strcmp(cstr, cstr2), 0); + + /* uint16v_t */ + uint16_t u16v2[sizeof(u16v) / sizeof(u16v[0])]; + for (int32_t i = 0; i < sizeof(u16v) / sizeof(u16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetU16v(&reader, &u16v2[i]), 0); + GTEST_ASSERT_EQ(u16v[i], u16v2[i]); + } + + /* uint32v_t */ + uint32_t u32v2[sizeof(u32v) / sizeof(u32v[0])]; + for (int32_t i = 0; i < sizeof(u32v) / sizeof(u32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetU32v(&reader, &u32v2[i]), 0); + GTEST_ASSERT_EQ(u32v[i], u32v2[i]); + } + + /* uint64v_t */ + uint64_t u64v2[sizeof(u64v) / sizeof(u64v[0])]; + for (int32_t i = 0; i < sizeof(u64v) / sizeof(u64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetU64v(&reader, &u64v2[i]), 0); + GTEST_ASSERT_EQ(u64v[i], u64v2[i]); + } + + /* int16v_t */ + int16_t i16v2[sizeof(i16v) / sizeof(i16v[0])]; + for (int32_t i = 0; i < sizeof(i16v) / sizeof(i16v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetI16v(&reader, &i16v2[i]), 0); + GTEST_ASSERT_EQ(i16v[i], i16v2[i]); + } + + /* int32v_t */ + int32_t i32v2[sizeof(i32v) / sizeof(i32v[0])]; + for (int32_t i = 0; i < sizeof(i32v) / sizeof(i32v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetI32v(&reader, &i32v2[i]), 0); + GTEST_ASSERT_EQ(i32v[i], i32v2[i]); + } + + /* int64v_t */ + int64_t i64v2[sizeof(i64v) / sizeof(i64v[0])]; + for (int32_t i = 0; i < sizeof(i64v) / sizeof(i64v[0]); ++i) { + GTEST_ASSERT_EQ(tBufferGetI64v(&reader, &i64v2[i]), 0); + GTEST_ASSERT_EQ(i64v[i], i64v2[i]); + } + + tBufferReaderDestroy(&reader); + + GTEST_ASSERT_EQ(reader.offset, writer.offset); + + // clear + tBufferDestroy(&buffer); +} \ No newline at end of file