Function TEST_F

bolt/buffer/tests/BufferTest.cpp:64–111

};

TEST_F(BufferTest, testAlignedBuffer) {
  static constexpr int32_t kHeaderSize = sizeof(AlignedBuffer);
  const int32_t size = 1024 * 7;
  const int32_t sizeWithHeader = size + kHeaderSize;
  BufferPtr other;
  {
    const char* testString = "1234567\0";
    const int32_t testStringLength = strlen(testString);
    BufferPtr buffer = AlignedBuffer::allocate<char>(size, pool_.get(), 'i');
    EXPECT_EQ(buffer->as<char>()[0], 'i');
    EXPECT_TRUE(buffer->isMutable());
    EXPECT_EQ(buffer->size(), size);
    EXPECT_GE(buffer->capacity(), size);
    buffer->setSize(buffer->capacity());
    memcpy(
        buffer->asMutable<uint8_t>() + buffer->capacity() - testStringLength,
        testString,
        testStringLength);
    other = buffer;
    EXPECT_EQ(pool_->currentBytes(), pool_->preferredSize(sizeWithHeader));

    AlignedBuffer::reallocate<char>(&other, size * 3, 'e');
    EXPECT_NE(other, buffer);

    // No longer multiply referenced.
    EXPECT_GE(other->capacity(), 3 * size);
    EXPECT_EQ(other->size(), 3 * size);
    EXPECT_EQ(
        memcmp(
            other->as<uint8_t>() + buffer->capacity() - testStringLength,
            testString,
            testStringLength),
        0);
    EXPECT_EQ(other->as<char>()[buffer->capacity()], 'e');
    EXPECT_EQ(
        pool_->currentBytes(),
        pool_->preferredSize(sizeWithHeader) +
            pool_->preferredSize(3 * size + kHeaderSize));
  }
  EXPECT_EQ(
      pool_->currentBytes(), pool_->preferredSize(3 * size + kHeaderSize));
  other = nullptr;
  BufferPtr bits = AlignedBuffer::allocate<bool>(65, pool_.get(), true);
  EXPECT_EQ(bits->size(), 9);
  EXPECT_EQ(bits->as<uint8_t>()[8], 0xff);
  bits = nullptr;
  EXPECT_EQ(pool_->currentBytes(), 0);
}

TEST_F(BufferTest, testAsRange) {
  // Simple 2 element vector.