write buffer pool

test/CMakeLists.txt

@@ -4,4 +4,6 @@ if(OJ_TEST_BPT)
   set_target_properties(code PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 endif()
 add_executable(replacer_test replacer_test.cpp)
-target_link_libraries(replacer_test bpt GTest::gtest_main)
+target_link_libraries(replacer_test bpt GTest::gtest_main)
+add_executable(buffer_pool_manager_test buffer_pool_manager_test.cpp)
+target_link_libraries(buffer_pool_manager_test bpt GTest::gtest_main)

test/buffer_pool_manager_test.cpp

@@ -0,0 +1,142 @@
+#include "bpt/buffer_pool_manager.h"
+#include <gtest/gtest.h>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <random>
+#include <string>
+#include "bpt/config.h"
+// Demonstrate some basic assertions.
+TEST(HelloTest, BasicAssertions) {
+  // Expect two strings not to be equal.
+  EXPECT_STRNE("hello", "world");
+  // Expect equality.
+  EXPECT_EQ(7 * 6, 42);
+}
+
+TEST(Basic, BasicTest) {
+  DiskManager disk_manager("/tmp/test.db");
+  BufferPoolManager buffer_pool_manager(10, 3, &disk_manager);
+}
+
+TEST(BufferPoolManagerTest, DISABLED_BinaryDataTest) {
+  const std::string db_name = "test.db";
+  const size_t buffer_pool_size = 10;
+  const size_t k = 5;
+
+  std::random_device r;
+  std::default_random_engine rng(r());
+  std::uniform_int_distribution<char> uniform_dist(0);
+
+  auto *disk_manager = new DiskManager(db_name);
+  auto *bpm = new BufferPoolManager(buffer_pool_size, k, disk_manager);
+
+  page_id_t page_id_temp;
+  auto *page0 = bpm->NewPage(&page_id_temp);
+
+  // Scenario: The buffer pool is empty. We should be able to create a new page.
+  ASSERT_NE(nullptr, page0);
+  EXPECT_EQ(1, page_id_temp);
+
+  char random_binary_data[kPageSize];
+  // Generate random binary data
+  for (char &i : random_binary_data) {
+    i = uniform_dist(rng);
+  }
+
+  // Insert terminal characters both in the middle and at end
+  random_binary_data[kPageSize / 2] = '\0';
+  random_binary_data[kPageSize - 1] = '\0';
+
+  // Scenario: Once we have a page, we should be able to read and write content.
+  std::memcpy(page0->GetData(), random_binary_data, kPageSize);
+  EXPECT_EQ(0, std::memcmp(page0->GetData(), random_binary_data, kPageSize));
+
+  // Scenario: We should be able to create new pages until we fill up the buffer pool.
+  for (size_t i = 1; i < buffer_pool_size; ++i) {
+    EXPECT_NE(nullptr, bpm->NewPage(&page_id_temp));
+  }
+
+  // Scenario: Once the buffer pool is full, we should not be able to create any new pages.
+  for (size_t i = buffer_pool_size; i < buffer_pool_size * 2; ++i) {
+    EXPECT_EQ(nullptr, bpm->NewPage(&page_id_temp));
+  }
+
+  // Scenario: After unpinning pages {0, 1, 2, 3, 4} we should be able to create 5 new pages
+  for (int i = 1; i <= 5; ++i) {
+    EXPECT_EQ(true, bpm->UnpinPage(i, true));
+    bpm->FlushPage(i);
+  }
+  for (int i = 1; i <= 5; ++i) {
+    EXPECT_NE(nullptr, bpm->NewPage(&page_id_temp));
+    bpm->UnpinPage(page_id_temp, false);
+  }
+  // Scenario: We should be able to fetch the data we wrote a while ago.
+  page0 = bpm->FetchPage(1);
+  EXPECT_EQ(0, memcmp(page0->GetData(), random_binary_data, kPageSize));
+  EXPECT_EQ(true, bpm->UnpinPage(1, true));
+
+  // Shutdown the disk manager and remove the temporary file we created.
+  disk_manager->Close();
+  remove("test.db");
+
+  delete bpm;
+  delete disk_manager;
+}
+
+// NOLINTNEXTLINE
+TEST(BufferPoolManagerTest, DISABLED_SampleTest) {
+  const std::string db_name = "test.db";
+  const size_t buffer_pool_size = 10;
+  const size_t k = 5;
+
+  auto *disk_manager = new DiskManager(db_name);
+  auto *bpm = new BufferPoolManager(buffer_pool_size, k, disk_manager);
+
+  page_id_t page_id_temp;
+  auto *page0 = bpm->NewPage(&page_id_temp);
+
+  // Scenario: The buffer pool is empty. We should be able to create a new page.
+  ASSERT_NE(nullptr, page0);
+  EXPECT_EQ(1, page_id_temp);
+
+  // Scenario: Once we have a page, we should be able to read and write content.
+  snprintf(page0->GetData(), kPageSize, "Hello");
+  EXPECT_EQ(0, strcmp(page0->GetData(), "Hello"));
+
+  // Scenario: We should be able to create new pages until we fill up the buffer pool.
+  for (size_t i = 2; i <= buffer_pool_size; ++i) {
+    EXPECT_NE(nullptr, bpm->NewPage(&page_id_temp));
+  }
+
+  // Scenario: Once the buffer pool is full, we should not be able to create any new pages.
+  for (size_t i = buffer_pool_size + 1; i <= buffer_pool_size * 2; ++i) {
+    EXPECT_EQ(nullptr, bpm->NewPage(&page_id_temp));
+  }
+
+  // Scenario: After unpinning pages {1, 2, 3, 4, 5} and pinning another 4 new pages,
+  // there would still be one buffer page left for reading page 0.
+  for (int i = 1; i <= 5; ++i) {
+    EXPECT_EQ(true, bpm->UnpinPage(i, true));
+  }
+  for (int i = 1; i <= 4; ++i) {
+    EXPECT_NE(nullptr, bpm->NewPage(&page_id_temp));
+  }
+
+  // Scenario: We should be able to fetch the data we wrote a while ago.
+  page0 = bpm->FetchPage(1);
+  EXPECT_EQ(0, strcmp(page0->GetData(), "Hello"));
+
+  // Scenario: If we unpin page 0 and then make a new page, all the buffer pages should
+  // now be pinned. Fetching page 0 should fail.
+  EXPECT_EQ(true, bpm->UnpinPage(1, true));
+  EXPECT_NE(nullptr, bpm->NewPage(&page_id_temp));
+  EXPECT_EQ(nullptr, bpm->FetchPage(1));
+
+  // Shutdown the disk manager and remove the temporary file we created.
+  disk_manager->Close();
+  remove("test.db");
+
+  delete bpm;
+  delete disk_manager;
+}