BlockStorage/repertory
1
0
Fork 0
Code Issues 7 Pull Requests Releases 6 Wiki Activity

refactor
All checks were successful
BlockStorage/repertory/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Scott E. Graves 2024-11-14 13:25:35 -06:00
parent d481aeae66
commit d03e6e8201
1 changed files with 140 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

285
repertory/repertory_test/src/ring_buffer_open_file_test.cpp
View File

@ -28,36 +28,39 @@
#include "utils/file_utils.hpp"
#include "utils/path.hpp"
namespace {
constexpr const std::size_t test_chunk_size{1024U};
std::string ring_buffer_dir = repertory::utils::path::combine(
repertory::test::get_test_output_dir(),
{"file_manager_ring_buffer_open_file_test"});
} // namespace
namespace repertory {
static constexpr const std::size_t test_chunk_size = 1024u;
static std::string ring_buffer_dir = utils::path::combine(
test::get_test_output_dir(), {"file_manager_ring_buffer_open_file_test"});
TEST(ring_buffer_open_file, can_forward_to_last_chunk) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 16u;
fsi.size = test_chunk_size * 16U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(0u, 3u);
rb.forward(4u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(0U, 3U);
file.forward(4U);
EXPECT_EQ(std::size_t(7u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(0u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(7u), rb.get_last_chunk());
for (std::size_t chunk = 0u; chunk < 8u; chunk++) {
EXPECT_TRUE(rb.get_read_state(chunk));
EXPECT_EQ(std::size_t(7U), file.get_current_chunk());
EXPECT_EQ(std::size_t(0U), file.get_first_chunk());
EXPECT_EQ(std::size_t(7U), file.get_last_chunk());
for (std::size_t chunk = 0U; chunk < 8U; chunk++) {
EXPECT_TRUE(file.get_read_state(chunk));
}
}
@ -66,30 +69,29 @@ TEST(ring_buffer_open_file, can_forward_to_last_chunk) {
TEST(ring_buffer_open_file,
can_forward_to_last_chunk_if_count_is_greater_than_remaining) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 16u;
fsi.size = test_chunk_size * 16U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(0u, 3u);
rb.forward(100u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(0U, 3U);
file.forward(100U);
EXPECT_EQ(std::size_t(15u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(8u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(15u), rb.get_last_chunk());
for (std::size_t chunk = 8u; chunk <= 15u; chunk++) {
EXPECT_FALSE(rb.get_read_state(chunk));
EXPECT_EQ(std::size_t(15U), file.get_current_chunk());
EXPECT_EQ(std::size_t(8U), file.get_first_chunk());
EXPECT_EQ(std::size_t(15U), file.get_last_chunk());
for (std::size_t chunk = 8U; chunk <= 15U; chunk++) {
EXPECT_FALSE(file.get_read_state(chunk));
}
}
@ -97,31 +99,30 @@ TEST(ring_buffer_open_file,
}
TEST(ring_buffer_open_file, can_forward_after_last_chunk) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 16u;
fsi.size = test_chunk_size * 16U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(0u, 3u);
rb.forward(5u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(0U, 3U);
file.forward(5U);
EXPECT_EQ(std::size_t(8u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(1u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(8u), rb.get_last_chunk());
EXPECT_FALSE(rb.get_read_state(8u));
for (std::size_t chunk = 1u; chunk < 8u; chunk++) {
EXPECT_TRUE(rb.get_read_state(chunk));
EXPECT_EQ(std::size_t(8U), file.get_current_chunk());
EXPECT_EQ(std::size_t(1U), file.get_first_chunk());
EXPECT_EQ(std::size_t(8U), file.get_last_chunk());
EXPECT_FALSE(file.get_read_state(8U));
for (std::size_t chunk = 1U; chunk < 8U; chunk++) {
EXPECT_TRUE(file.get_read_state(chunk));
}
}
@ -129,58 +130,56 @@ TEST(ring_buffer_open_file, can_forward_after_last_chunk) {
}
TEST(ring_buffer_open_file, can_forward_and_rollover_after_last_chunk) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 32u;
fsi.size = test_chunk_size * 32U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(16u, 20u);
rb.forward(8u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(16U, 20U);
file.forward(8U);
EXPECT_EQ(std::size_t(28u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(21u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(28u), rb.get_last_chunk());
EXPECT_EQ(std::size_t(28U), file.get_current_chunk());
EXPECT_EQ(std::size_t(21U), file.get_first_chunk());
EXPECT_EQ(std::size_t(28U), file.get_last_chunk());
}
EXPECT_TRUE(utils::file::directory(ring_buffer_dir).remove_recursively());
}
TEST(ring_buffer_open_file, can_reverse_to_first_chunk) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 16u;
fsi.size = test_chunk_size * 16U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(0u, 3u);
rb.reverse(3u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(0U, 3U);
file.reverse(3U);
EXPECT_EQ(std::size_t(0u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(0u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(7u), rb.get_last_chunk());
for (std::size_t chunk = 0u; chunk < 8u; chunk++) {
EXPECT_TRUE(rb.get_read_state(chunk));
EXPECT_EQ(std::size_t(0U), file.get_current_chunk());
EXPECT_EQ(std::size_t(0U), file.get_first_chunk());
EXPECT_EQ(std::size_t(7U), file.get_last_chunk());
for (std::size_t chunk = 0U; chunk < 8U; chunk++) {
EXPECT_TRUE(file.get_read_state(chunk));
}
}
@ -189,30 +188,29 @@ TEST(ring_buffer_open_file, can_reverse_to_first_chunk) {
TEST(ring_buffer_open_file,
can_reverse_to_first_chunk_if_count_is_greater_than_remaining) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 16u;
fsi.size = test_chunk_size * 16U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(0u, 3u);
rb.reverse(13u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(0U, 3U);
file.reverse(13U);
EXPECT_EQ(std::size_t(0u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(0u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(7u), rb.get_last_chunk());
for (std::size_t chunk = 0u; chunk < 8u; chunk++) {
EXPECT_TRUE(rb.get_read_state(chunk));
EXPECT_EQ(std::size_t(0U), file.get_current_chunk());
EXPECT_EQ(std::size_t(0U), file.get_first_chunk());
EXPECT_EQ(std::size_t(7U), file.get_last_chunk());
for (std::size_t chunk = 0U; chunk < 8U; chunk++) {
EXPECT_TRUE(file.get_read_state(chunk));
}
}
@ -220,31 +218,30 @@ TEST(ring_buffer_open_file,
}
TEST(ring_buffer_open_file, can_reverse_before_first_chunk) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 16u;
fsi.size = test_chunk_size * 16U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(1u, 3u);
rb.reverse(3u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(1U, 3U);
file.reverse(3U);
EXPECT_EQ(std::size_t(0u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(0u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(7u), rb.get_last_chunk());
EXPECT_FALSE(rb.get_read_state(0u));
for (std::size_t chunk = 1u; chunk < 8u; chunk++) {
EXPECT_TRUE(rb.get_read_state(chunk));
EXPECT_EQ(std::size_t(0U), file.get_current_chunk());
EXPECT_EQ(std::size_t(0U), file.get_first_chunk());
EXPECT_EQ(std::size_t(7U), file.get_last_chunk());
EXPECT_FALSE(file.get_read_state(0U));
for (std::size_t chunk = 1U; chunk < 8U; chunk++) {
EXPECT_TRUE(file.get_read_state(chunk));
}
}
@ -252,35 +249,34 @@ TEST(ring_buffer_open_file, can_reverse_before_first_chunk) {
}
TEST(ring_buffer_open_file, can_reverse_and_rollover_before_first_chunk) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 32u;
fsi.size = test_chunk_size * 32U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(16u, 20u);
rb.reverse(8u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(16U, 20U);
file.reverse(8U);
EXPECT_EQ(std::size_t(12u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(12u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(19u), rb.get_last_chunk());
EXPECT_EQ(std::size_t(12U), file.get_current_chunk());
EXPECT_EQ(std::size_t(12U), file.get_first_chunk());
EXPECT_EQ(std::size_t(19U), file.get_last_chunk());
EXPECT_FALSE(rb.get_read_state(12u));
EXPECT_FALSE(rb.get_read_state(13u));
EXPECT_FALSE(rb.get_read_state(14u));
EXPECT_FALSE(rb.get_read_state(15u));
for (std::size_t chunk = 16u; chunk <= rb.get_last_chunk(); chunk++) {
EXPECT_TRUE(rb.get_read_state(chunk));
EXPECT_FALSE(file.get_read_state(12U));
EXPECT_FALSE(file.get_read_state(13U));
EXPECT_FALSE(file.get_read_state(14U));
EXPECT_FALSE(file.get_read_state(15U));
for (std::size_t chunk = 16U; chunk <= file.get_last_chunk(); chunk++) {
EXPECT_TRUE(file.get_read_state(chunk));
}
}
@ -288,31 +284,30 @@ TEST(ring_buffer_open_file, can_reverse_and_rollover_before_first_chunk) {
}
TEST(ring_buffer_open_file, can_reverse_full_ring) {
const auto source_path =
test::generate_test_file_name("ring_buffer_open_file");
auto source_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
mock_provider prov;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(prov, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 32u;
fsi.size = test_chunk_size * 32U;
fsi.source_path = source_path;
{
ring_buffer_open_file rb(ring_buffer_dir, test_chunk_size, 30U, fsi, mp,
8u);
rb.set(8u, 15u);
rb.reverse(16u);
ring_buffer_open_file file(ring_buffer_dir, test_chunk_size, 30U, fsi, prov,
8U);
file.set(8U, 15U);
file.reverse(16U);
EXPECT_EQ(std::size_t(0u), rb.get_current_chunk());
EXPECT_EQ(std::size_t(0u), rb.get_first_chunk());
EXPECT_EQ(std::size_t(7u), rb.get_last_chunk());
EXPECT_EQ(std::size_t(0U), file.get_current_chunk());
EXPECT_EQ(std::size_t(0U), file.get_first_chunk());
EXPECT_EQ(std::size_t(7U), file.get_last_chunk());
for (std::size_t chunk = 0u; chunk <= rb.get_last_chunk(); chunk++) {
EXPECT_FALSE(rb.get_read_state(chunk));
for (std::size_t chunk = 0U; chunk <= file.get_last_chunk(); chunk++) {
EXPECT_FALSE(file.get_read_state(chunk));
}
}
@ -321,9 +316,9 @@ TEST(ring_buffer_open_file, can_reverse_full_ring) {
TEST(ring_buffer_open_file, read_full_file) {
auto &nf = test::create_random_file(test_chunk_size * 32u);
const auto download_source_path = nf.get_path();
auto download_source_path = nf.get_path();
const auto dest_path = test::generate_test_file_name("ring_buffer_open_file");
auto dest_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
@ -386,9 +381,9 @@ TEST(ring_buffer_open_file, read_full_file) {
TEST(ring_buffer_open_file, read_full_file_in_reverse) {
auto &nf = test::create_random_file(test_chunk_size * 32u);
const auto download_source_path = nf.get_path();
auto download_source_path = nf.get_path();
const auto dest_path = test::generate_test_file_name("ring_buffer_open_file");
auto dest_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
@ -451,9 +446,9 @@ TEST(ring_buffer_open_file, read_full_file_in_reverse) {
TEST(ring_buffer_open_file, read_full_file_in_partial_chunks) {
auto &nf = test::create_random_file(test_chunk_size * 32u);
const auto download_source_path = nf.get_path();
auto download_source_path = nf.get_path();
const auto dest_path = test::generate_test_file_name("test");
auto dest_path = test::generate_test_file_name("test");
mock_provider mp;
@ -517,9 +512,9 @@ TEST(ring_buffer_open_file, read_full_file_in_partial_chunks) {
TEST(ring_buffer_open_file, read_full_file_in_partial_chunks_in_reverse) {
auto &nf = test::create_random_file(test_chunk_size * 32u);
const auto download_source_path = nf.get_path();
auto download_source_path = nf.get_path();
const auto dest_path = test::generate_test_file_name("ring_buffer_open_file");
auto dest_path = test::generate_test_file_name("ring_buffer_open_file");
mock_provider mp;
@ -553,11 +548,11 @@ TEST(ring_buffer_open_file, read_full_file_in_partial_chunks_in_reverse) {
EXPECT_TRUE(nf2);
std::uint64_t total_read{0U};
const auto read_size{3U};
auto read_size{3U};
while (total_read < fsi.size) {
const auto offset = fsi.size - total_read - read_size;
const auto remain = fsi.size - total_read;
auto offset = fsi.size - total_read - read_size;
auto remain = fsi.size - total_read;
data_buffer data{};
EXPECT_EQ(api_error::success,