oceanbase/unittest/storage/blocksstable/test_data_buffer.cpp

/**
 * Copyright (c) 2021 OceanBase
 * OceanBase CE is licensed under Mulan PubL v2.
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
 * You may obtain a copy of Mulan PubL v2 at:
 *          http://license.coscl.org.cn/MulanPubL-2.0
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PubL v2 for more details.
 */

#include <gtest/gtest.h>
#include <signal.h>
#include "storage/blocksstable/ob_data_buffer.h"
#include "common/object/ob_object.h"
#include "storage/blocksstable/ob_block_sstable_struct.h"

namespace oceanbase {
using namespace common;
namespace blocksstable {

class TestDataBuffer : public ::testing::Test {
public:
  TestDataBuffer();
  virtual ~TestDataBuffer();
  virtual void SetUp();
  virtual void TearDown();

protected:
  char* buf_;
  int64_t buf_size_;
};

TestDataBuffer::TestDataBuffer() : buf_(NULL), buf_size_(0)
{}

TestDataBuffer::~TestDataBuffer()
{}

void TestDataBuffer::SetUp()
{
  buf_size_ = 2L * 1024 * 1024;
  buf_ = static_cast<char*>(malloc(buf_size_));
  ASSERT_FALSE(NULL == buf_);
}

void TestDataBuffer::TearDown()
{
  if (NULL != buf_) {
    free(buf_);
  }
}

TEST_F(TestDataBuffer, test_ObSelfBufferWriter)
{
  int ret = OB_SUCCESS;
  int64_t big_size = 256L * 1024L * 1024L * 1024L * 1024L * 1024L;  // 256TB
  ObSelfBufferWriter buf_align(4096, ObModIds::TEST, true);
  ObSelfBufferWriter buf_not_align(0, ObModIds::TEST, false);
  ret = buf_align.ensure_space(4096);
  ASSERT_EQ(ret, OB_SUCCESS);

  ret = buf_align.ensure_space(4097);
  ASSERT_EQ(ret, OB_INVALID_ARGUMENT);

  ret = buf_not_align.ensure_space(big_size);
  ASSERT_EQ(ret, OB_ALLOCATE_MEMORY_FAILED);

  ret = buf_align.ensure_space(big_size);
  ASSERT_EQ(ret, OB_ALLOCATE_MEMORY_FAILED);

  ret = buf_align.ensure_space(buf_size_);
  ASSERT_EQ(ret, OB_SUCCESS);

  ret = buf_align.expand(buf_size_);
  ASSERT_EQ(ret, OB_SUCCESS);

  ret = buf_not_align.ensure_space(buf_size_);
  ASSERT_EQ(ret, OB_SUCCESS);

  ret = buf_align.ensure_space(big_size);
  ASSERT_EQ(ret, OB_ALLOCATE_MEMORY_FAILED);
}

TEST_F(TestDataBuffer, test_ObBufferHolder)
{
  // rollback and advance test
  ObBufferWriter buffer_writer(buf_, buf_size_);
  const int64_t tmp = 1234;
  ASSERT_EQ(OB_BUF_NOT_ENOUGH, buffer_writer.rollback(tmp));
  ASSERT_EQ(OB_SUCCESS, buffer_writer.set_pos(buf_size_));
  ASSERT_EQ(OB_BUF_NOT_ENOUGH, buffer_writer.advance(sizeof(int64_t)));
  ASSERT_EQ(OB_SUCCESS, buffer_writer.rollback(tmp));
  ASSERT_EQ(OB_SUCCESS, buffer_writer.advance(sizeof(int64_t)));
  ASSERT_EQ(buffer_writer.length(), buf_size_);
  // write_pod and read_pod get
  int64_t pod = INT64_MAX;
  int64_t read_pod = 0;
  const int64_t* get_pod = NULL;
  buffer_writer.assign(buf_, buf_size_);
  ObBufferReader buffer_reader(buf_, buf_size_);
  memset(buf_, 0, buf_size_);
  ASSERT_EQ(OB_SUCCESS, buffer_writer.write(pod));
  ASSERT_EQ(OB_SUCCESS, buffer_reader.read(read_pod));
  ASSERT_EQ(pod, read_pod);
  ASSERT_EQ(buffer_writer.length(), buffer_reader.length());
  ASSERT_EQ(OB_SUCCESS, buffer_writer.write(pod));
  ASSERT_EQ(OB_SUCCESS, buffer_reader.get(get_pod));
  ASSERT_FALSE(NULL == get_pod);
  ASSERT_EQ(pod, *get_pod);
  ASSERT_EQ(buffer_writer.length(), buffer_reader.length());
  // write and read buf test
  char write_buf[10] = "test";
  char read_buf[10];
  ASSERT_EQ(OB_SUCCESS, buffer_writer.write(write_buf, 10));
  ASSERT_EQ(OB_SUCCESS, buffer_reader.read(read_buf, 10));
  ASSERT_EQ(0, memcmp(write_buf, read_buf, 10));
  ASSERT_EQ(buffer_writer.length(), buffer_reader.length());
  // write_serialize and read_serizlize
  ObObj write_key;
  ObObj read_key;
  write_key.set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
  write_key.set_varchar("test");
  ASSERT_TRUE(write_key != read_key);
  ASSERT_EQ(OB_SUCCESS, buffer_writer.write_serialize(write_key));
  ASSERT_EQ(OB_SUCCESS, buffer_reader.read_serialize(read_key));
  ASSERT_TRUE(write_key == read_key);
  ASSERT_EQ(buffer_writer.length(), buffer_reader.length());
  // write and read
  pod = INT64_MAX;
  ASSERT_EQ(OB_SUCCESS, buffer_writer.write(pod));
  ASSERT_EQ(OB_SUCCESS, buffer_reader.read(read_pod));
  ASSERT_EQ(pod, read_pod);
  ASSERT_EQ(buffer_writer.length(), buffer_reader.length());
  // append_fmt
  char* buf_read = NULL;
  ASSERT_EQ(OB_SUCCESS, buffer_writer.append_fmt("%s", "oceanbase"));
  ASSERT_EQ(OB_SUCCESS, buffer_reader.read_cstr(buf_read));
  ASSERT_EQ(0, memcmp(buf_read, "oceanbase", sizeof("oceanbase")));
}

TEST_F(TestDataBuffer, test_data_buffer_append_fmt_need_size)
{
  common::ObArenaAllocator allocator;
  const char* str = "123";
  char* buf = static_cast<char*>(allocator.alloc(4));
  ObBufferWriter buffer_writer(buf, 4);
  ASSERT_NE(nullptr, buf);
  ASSERT_EQ(OB_SUCCESS, buffer_writer.append_fmt("%s", str));
}

TEST_F(TestDataBuffer, test_data_buffer_reader_read_str)
{
  common::ObArenaAllocator allocator;
  const char* str = "123";
  char* buf = static_cast<char*>(allocator.alloc(4));
  MEMCPY(buf, "123", 4);
  ObBufferReader buffer_reader(buf, 4);
  char* read_str = nullptr;
  ASSERT_EQ(OB_SUCCESS, buffer_reader.read_cstr(read_str));
  ASSERT_EQ(4, buffer_reader.pos());
}

TEST_F(TestDataBuffer, test_ObBufferReader)
{
  int64_t buf_len = 1024 * 1024;
  char* buf = (char*)malloc(buf_len);
  int64_t pos = 0;

  ObBufferReader buffer_reader(buf_, 16384, 16384);
  ASSERT_EQ(OB_SUCCESS, buffer_reader.serialize(buf, buf_len, pos));
  COMMON_LOG(INFO, "dump", "need_size", buffer_reader.get_serialize_size(), K(buffer_reader), K(pos));

  ObBufferReader buffer_reader2;
  pos = 0;
  ASSERT_EQ(OB_SUCCESS, buffer_reader2.deserialize(buf, buf_len, pos));
  COMMON_LOG(INFO, "dump", K(buffer_reader), K(pos), K(buffer_reader2));
}
}  // namespace blocksstable
}  // namespace oceanbase
int main(int argc, char** argv)
{
  OB_LOGGER.set_log_level("INFO");
  testing::InitGoogleTest(&argc, argv);
  oceanbase::lib::set_memory_limit(40UL << 30);
  signal(49, SIG_IGN);
  return RUN_ALL_TESTS();
}