Skip to content

Commit 2cdf09d

Browse files
poyrazKpoyrazK
authored
Merge pull request #2 from poyrazK/chore/gtest-migration
chore: migrate custom testing framework to GoogleTest
2 parents 0365aeb + e96a862 commit 2cdf09d

10 files changed

Lines changed: 222 additions & 1505 deletions

‎CMakeLists.txt‎

Lines changed: 26 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -120,42 +120,34 @@ endif()
120120

121121
# Build test executables
122122
if (BUILD_TESTS)
123-
# Create test executable
124-
add_executable(sqlEngine_tests tests/cloudSQL_tests.cpp)
125-
target_link_libraries(sqlEngine_tests PRIVATE sqlEngineCore)
126-
127-
# Create lock manager unit tests
128-
add_executable(lock_manager_tests tests/lock_manager_tests.cpp)
129-
target_link_libraries(lock_manager_tests PRIVATE sqlEngineCore)
130-
131-
# Create server unit tests
132-
add_executable(server_tests tests/server_tests.cpp)
133-
target_link_libraries(server_tests PRIVATE sqlEngineCore)
134-
135-
# Create transaction manager unit tests
136-
add_executable(transaction_manager_tests tests/transaction_manager_tests.cpp)
137-
target_link_libraries(transaction_manager_tests PRIVATE sqlEngineCore)
138-
139-
# Create statement unit tests
140-
add_executable(statement_tests tests/statement_tests.cpp)
141-
target_link_libraries(statement_tests PRIVATE sqlEngineCore)
142-
143-
# Create recovery unit tests
144-
add_executable(recovery_tests tests/recovery_tests.cpp)
145-
target_link_libraries(recovery_tests PRIVATE sqlEngineCore)
146-
147-
# Check if GoogleTest is available
148-
find_package(GTest QUIET)
149-
if (GTest_FOUND)
150-
target_link_libraries(sqlEngine_tests PRIVATE GTest::GTest GTest::GTestMain)
151-
include(GoogleTest)
152-
gtest_discover_tests(sqlEngine_tests)
153-
endif()
123+
enable_testing()
124+
include(FetchContent)
125+
FetchContent_Declare(
126+
googletest
127+
URL https://github.com/google/googletest/archive/refs/heads/main.zip
128+
)
129+
# For Windows: prevent overriding the parent project's compiler/linker settings
130+
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
131+
FetchContent_MakeAvailable(googletest)
132+
133+
macro(add_cloudsql_test name source)
134+
add_executable(${name} ${source})
135+
target_link_libraries(${name} PRIVATE sqlEngineCore GTest::gtest_main)
136+
add_test(NAME ${name} COMMAND ${name})
137+
endmacro()
138+
139+
add_cloudsql_test(sqlEngine_tests tests/cloudSQL_tests.cpp)
140+
add_cloudsql_test(lock_manager_tests tests/lock_manager_tests.cpp)
141+
add_cloudsql_test(server_tests tests/server_tests.cpp)
142+
add_cloudsql_test(transaction_manager_tests tests/transaction_manager_tests.cpp)
143+
add_cloudsql_test(statement_tests tests/statement_tests.cpp)
144+
add_cloudsql_test(recovery_tests tests/recovery_tests.cpp)
145+
add_cloudsql_test(recovery_manager_tests tests/recovery_manager_tests.cpp)
146+
add_cloudsql_test(buffer_pool_tests tests/buffer_pool_tests.cpp)
154147

155148
add_custom_target(run-tests
156-
COMMAND ${CMAKE_CURRENT_BINARY_DIR}/sqlEngine_tests
157-
DEPENDS sqlEngine_tests
158-
COMMENT "Running cloudSQL tests")
149+
COMMAND ${CMAKE_CTEST_COMMAND}
150+
COMMENT "Running all tests via CTest")
159151
endif()
160152

161153
# Installation

‎tests/buffer_pool_tests.cpp‎

Lines changed: 33 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -3,170 +3,60 @@
33
* @brief Unit tests for Buffer Pool Manager
44
*/
55

6+
#include <gtest/gtest.h>
7+
8+
#include <cstdint>
69
#include <cstdio>
7-
#include <iostream>
10+
#include <cstring>
811
#include <string>
9-
#include <vector>
1012

1113
#include "storage/buffer_pool_manager.hpp"
12-
#include "storage/lru_replacer.hpp"
1314
#include "storage/page.hpp"
1415
#include "storage/storage_manager.hpp"
15-
#include "test_utils.hpp"
1616

1717
using namespace cloudsql::storage;
1818

1919
namespace {
2020

21-
using cloudsql::tests::tests_failed;
22-
using cloudsql::tests::tests_passed;
23-
24-
TEST(LRUReplacer_Basic) {
25-
LRUReplacer replacer(3);
26-
uint32_t victim_frame = 0;
27-
28-
replacer.unpin(1);
29-
replacer.unpin(2);
30-
replacer.unpin(3);
31-
EXPECT_EQ(replacer.size(), 3u);
32-
33-
EXPECT_TRUE(replacer.victim(&victim_frame));
34-
EXPECT_EQ(victim_frame, 1u);
35-
EXPECT_EQ(replacer.size(), 2u);
36-
37-
replacer.unpin(4);
38-
EXPECT_EQ(replacer.size(), 3u);
39-
40-
EXPECT_TRUE(replacer.victim(&victim_frame));
41-
EXPECT_EQ(victim_frame, 2u);
42-
EXPECT_EQ(replacer.size(), 2u);
43-
44-
replacer.pin(3);
45-
EXPECT_EQ(replacer.size(), 1u);
46-
47-
replacer.unpin(3);
48-
EXPECT_EQ(replacer.size(), 2u);
49-
50-
EXPECT_TRUE(replacer.victim(&victim_frame));
51-
EXPECT_EQ(victim_frame, 4u);
52-
53-
EXPECT_TRUE(replacer.victim(&victim_frame));
54-
EXPECT_EQ(victim_frame, 3u);
55-
EXPECT_EQ(replacer.size(), 0u);
56-
57-
EXPECT_FALSE(replacer.victim(&victim_frame));
58-
}
59-
60-
TEST(BufferPoolManager_Basic) {
61-
static_cast<void>(std::remove("./test_data/bpm_test.db"));
62-
StorageManager disk_manager("./test_data");
63-
BufferPoolManager bpm(2, disk_manager);
64-
65-
const std::string file_name = "bpm_test.db";
66-
uint32_t page_id0 = 0;
67-
Page* page0 = bpm.new_page(file_name, &page_id0);
68-
EXPECT_TRUE(page0 != nullptr);
69-
EXPECT_EQ(page_id0, 0u);
70-
71-
EXPECT_TRUE(bpm.unpin_page(file_name, page_id0, true));
72-
73-
page0 = bpm.fetch_page(file_name, page_id0);
74-
EXPECT_TRUE(page0 != nullptr);
75-
EXPECT_TRUE(page0->is_dirty());
76-
EXPECT_TRUE(bpm.unpin_page(file_name, page_id0, false));
77-
78-
uint32_t page_id1 = 1;
79-
Page* page1 = bpm.new_page(file_name, &page_id1);
80-
EXPECT_TRUE(page1 != nullptr);
21+
constexpr size_t HELLO_LEN = 6;
8122

82-
uint32_t page_id2 = 2;
83-
Page* page2 = bpm.new_page(file_name, &page_id2);
84-
EXPECT_TRUE(page2 != nullptr);
23+
TEST(BufferPoolTests, Basic) {
24+
const std::string filename = "test.db";
25+
static_cast<void>(std::remove(filename.c_str()));
8526

86-
uint32_t page_id3 = 3;
87-
Page* page3 = bpm.new_page(file_name, &page_id3);
88-
EXPECT_FALSE(page3 != nullptr);
89-
90-
bpm.unpin_page(file_name, page_id1, false);
91-
bpm.unpin_page(file_name, page_id2, true);
92-
93-
page3 = bpm.new_page(file_name, &page_id3);
94-
EXPECT_TRUE(page3 != nullptr);
95-
96-
bpm.flush_page(file_name, page_id3);
97-
bpm.flush_all_pages();
98-
bpm.unpin_page(file_name, page_id3, false);
99-
100-
bpm.delete_page(file_name, page_id2);
101-
}
102-
103-
TEST(BufferPoolManager_Eviction) {
104-
static_cast<void>(std::remove("./test_data/bpm_eviction.db"));
105-
StorageManager disk_manager("./test_data");
27+
StorageManager disk_manager(".");
10628
BufferPoolManager bpm(3, disk_manager);
107-
const std::string file = "bpm_eviction.db";
108-
109-
uint32_t id1 = 1, id2 = 2, id3 = 3, id4 = 4;
110-
Page* p1 = bpm.new_page(file, &id1);
111-
Page* p2 = bpm.new_page(file, &id2);
112-
Page* p3 = bpm.new_page(file, &id3);
113-
114-
EXPECT_TRUE(p1 != nullptr);
115-
EXPECT_TRUE(p2 != nullptr);
116-
EXPECT_TRUE(p3 != nullptr);
11729

118-
bpm.unpin_page(file, id1, true);
119-
bpm.unpin_page(file, id2, false);
120-
bpm.unpin_page(file, id3, false);
30+
EXPECT_TRUE(bpm.open_file(filename));
12131

122-
Page* p4 = bpm.new_page(file, &id4);
123-
EXPECT_TRUE(p4 != nullptr);
32+
const uint32_t page_id1 = 0;
33+
Page* const page1 = bpm.new_page(filename, &page_id1);
34+
ASSERT_NE(page1, nullptr);
35+
EXPECT_EQ(page_id1, 0);
12436

125-
bpm.unpin_page(file, id4, false);
37+
std::memcpy(page1->get_data(), "Hello", HELLO_LEN);
38+
bpm.unpin_page(filename, page_id1, true);
12639

127-
p1 = bpm.fetch_page(file, id1);
128-
EXPECT_TRUE(p1 != nullptr);
129-
bpm.unpin_page(file, id1, false);
40+
const uint32_t page_id2 = 1;
41+
const Page* const page2 = bpm.new_page(filename, &page_id2);
42+
ASSERT_NE(page2, nullptr);
43+
EXPECT_EQ(page_id2, 1);
44+
bpm.unpin_page(filename, page_id2, false);
13045

131-
bpm.delete_page(file, id1);
132-
bpm.delete_page(file, id2);
133-
bpm.delete_page(file, id3);
134-
bpm.delete_page(file, id4);
135-
}
136-
137-
TEST(BufferPoolManager_EdgeCases) {
138-
static_cast<void>(std::remove("./test_data/bpm_edge.db"));
139-
StorageManager disk_manager("./test_data");
140-
BufferPoolManager bpm(1, disk_manager);
141-
const std::string file = "bpm_edge.db";
142-
143-
EXPECT_FALSE(bpm.unpin_page(file, 999, false));
144-
EXPECT_FALSE(bpm.flush_page(file, 999));
145-
EXPECT_TRUE(bpm.delete_page(file, 999));
146-
147-
uint32_t id = 1;
148-
Page* p = bpm.new_page(file, &id);
149-
EXPECT_TRUE(p != nullptr);
150-
EXPECT_FALSE(bpm.delete_page(file, id)); // Pinned
46+
const uint32_t page_id3 = 2;
47+
const Page* const page3 = bpm.new_page(filename, &page_id3);
48+
ASSERT_NE(page3, nullptr);
49+
EXPECT_EQ(page_id3, 2);
50+
bpm.unpin_page(filename, page_id3, false);
15151

152-
// new page again with same ID
153-
Page* p_dup = bpm.new_page(file, &id);
154-
EXPECT_TRUE(p_dup == nullptr);
52+
// Fetch page 1 again
53+
Page* const page1_fetch = bpm.fetch_page(filename, page_id1);
54+
ASSERT_NE(page1_fetch, nullptr);
55+
EXPECT_STREQ(page1_fetch->get_data(), "Hello");
56+
bpm.unpin_page(filename, page_id1, false);
15557

156-
bpm.unpin_page(file, id, false);
58+
static_cast<void>(bpm.close_file(filename));
59+
static_cast<void>(std::remove(filename.c_str()));
15760
}
15861

15962
} // namespace
160-
161-
int main() {
162-
std::cout << "Buffer Pool Unit Tests\n";
163-
std::cout << "======================\n";
164-
165-
RUN_TEST(LRUReplacer_Basic);
166-
RUN_TEST(BufferPoolManager_Basic);
167-
RUN_TEST(BufferPoolManager_Eviction);
168-
RUN_TEST(BufferPoolManager_EdgeCases);
169-
170-
std::cout << "\nResults: \n" << tests_passed << " passed, \n" << tests_failed << " failed\n";
171-
return (tests_failed > 0);
172-
}

0 commit comments

Comments
 (0)