diff --git a/repertory/repertory_test/src/ring_buffer_open_file_test.cpp b/repertory/repertory_test/src/ring_buffer_open_file_test.cpp
index 38ef392d..2dae1a0c 100644
--- a/repertory/repertory_test/src/ring_buffer_open_file_test.cpp
+++ b/repertory/repertory_test/src/ring_buffer_open_file_test.cpp
@@ -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,