feat: Add file-based persistence handler

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}

src/common/filesettingspersistence.cpp

@@ -0,0 +1,82 @@
+// class header include
+#include "displaydevice/filesettingspersistence.h"
+
+// system includes
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+
+// local includes
+#include "displaydevice/logging.h"
+
+namespace display_device {
+ FileSettingsPersistence::FileSettingsPersistence(std::filesystem::path filepath):
+ m_filepath { std::move(filepath) } {
+ if (m_filepath.empty()) {
+ throw std::runtime_error { "Empty filename provided for FileSettingsPersistence!" };
+ }
+ }
+
+ bool
+ FileSettingsPersistence::store(const std::vector<std::uint8_t> &data) {
+ try {
+ std::ofstream stream { m_filepath, std::ios::binary | std::ios::trunc };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for writing!";
+ return false;
+ }
+
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { stream });
+ return true;
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to write to " << m_filepath << "! Error:\n"
+ << error.what();
+ return false;
+ }
+ }
+
+ std::optional<std::vector<std::uint8_t>>
+ FileSettingsPersistence::load() const {
+ if (std::error_code error_code; !std::filesystem::exists(m_filepath, error_code)) {
+ if (error_code) {
+ DD_LOG(error) << "Failed to load " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> {};
+ }
+
+ try {
+ std::ifstream stream { m_filepath, std::ios::binary };
+ if (!stream) {
+ DD_LOG(error) << "Failed to open " << m_filepath << " for reading!";
+ return std::nullopt;
+ }
+
+ return std::vector<std::uint8_t> { std::istreambuf_iterator<char> { stream },
+ std::istreambuf_iterator<char> {} };
+ }
+ catch (const std::exception &error) {
+ DD_LOG(error) << "Failed to read " << m_filepath << "! Error:\n"
+ << error.what();
+ return std::nullopt;
+ }
+ }
+
+ bool
+ FileSettingsPersistence::clear() {
+ // Return valud does not matter since we check the error code in case the file could NOT be removed.
+ std::error_code error_code;
+ std::filesystem::remove(m_filepath, error_code);
+
+ if (error_code) {
+ DD_LOG(error) << "Failed to remove " << m_filepath << "! Error:\n"
+ << "[" << error_code.value() << "] " << error_code.message();
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

src/common/include/displaydevice/filesettingspersistence.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// system includes
+#include <filesystem>
+
+// local includes
+#include "settingspersistenceinterface.h"
+
+namespace display_device {
+ /**
+ * @brief Implementation of the SettingsPersistenceInterface,
+ * that saves/loads the persistent settings to/from the file.
+ */
+ class FileSettingsPersistence: public SettingsPersistenceInterface {
+ public:
+ /**
+ * Default constructor. Does not perform any operations on the file yet.
+ * @param filepath A non-empty filepath. Throws on empty.
+ */
+ explicit FileSettingsPersistence(std::filesystem::path filepath);
+
+ /**
+ * Store the data in the file specified in constructor.
+ * @warning The method does not create missing directories!
+ * @see SettingsPersistenceInterface::store for more details.
+ */
+ [[nodiscard]] bool
+ store(const std::vector<std::uint8_t> &data) override;
+
+ /**
+ * Read the data from the file specified in constructor.
+ * @note If file does not exist, an empty data list will be returned instead of null optional.
+ * @see SettingsPersistenceInterface::load for more details.
+ */
+ [[nodiscard]] std::optional<std::vector<std::uint8_t>>
+ load() const override;
+
+ /**
+ * Remove the file specified in constructor (if it exists).
+ * @see SettingsPersistenceInterface::clear for more details.
+ */
+ [[nodiscard]] bool
+ clear() override;
+
+ private:
+ std::filesystem::path m_filepath;
+ };
+} // namespace display_device

src/common/include/displaydevice/settingspersistenceinterface.h

@@ -48,6 +48,7 @@ namespace display_device {
 
  /**
  * @brief Clear the persistent settings data.
+ * @returns True if data was cleared, false otherwise.
  *
  * EXAMPLES:
  * ```cpp

tests/unit/general/test_filesettingspersistence.cpp

@@ -0,0 +1,115 @@
+// system includes
+#include <fstream>
+#include <gmock/gmock.h>
+
+// local includes
+#include "displaydevice/filesettingspersistence.h"
+#include "fixtures/fixtures.h"
+
+namespace {
+ // Convenience keywords for GMock
+ using ::testing::HasSubstr;
+
+ // Test fixture(s) for this file
+ class FileSettingsPersistenceTest: public BaseTest {
+ public:
+ ~FileSettingsPersistenceTest() override {
+ std::filesystem::remove(m_filepath);
+ }
+
+ display_device::FileSettingsPersistence &
+ getImpl(const std::filesystem::path &filepath = "testfile.ext") {
+ if (!m_impl) {
+ m_filepath = filepath;
+ m_impl = std::make_unique<display_device::FileSettingsPersistence>(m_filepath);
+ }
+
+ return *m_impl;
+ }
+
+ private:
+ std::filesystem::path m_filepath;
+ std::unique_ptr<display_device::FileSettingsPersistence> m_impl;
+ };
+
+ // Specialized TEST macro(s) for this test file
+#define TEST_F_S(...) DD_MAKE_TEST(TEST_F, FileSettingsPersistenceTest, __VA_ARGS__)
+} // namespace
+
+TEST_F_S(EmptyFilenameProvided) {
+ EXPECT_THAT([]() { const display_device::FileSettingsPersistence persistence { {} }; },
+ ThrowsMessage<std::runtime_error>(HasSubstr("Empty filename provided for FileSettingsPersistence!")));
+}
+
+TEST_F_S(Store, NewFileCreated) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data);
+}
+
+TEST_F_S(Store, FileOverwritten) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data1 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '1' };
+ const std::vector<std::uint8_t> data2 { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A', ' ', '2' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data1, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).store(data2));
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+
+ std::ifstream stream { filepath, std::ios::binary };
+ std::vector<std::uint8_t> file_data { std::istreambuf_iterator<char> { stream }, std::istreambuf_iterator<char> {} };
+ EXPECT_EQ(file_data, data2);
+}
+
+TEST_F_S(Store, FilepathWithDirectory) {
+ const std::filesystem::path filepath { "somedir/myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+ EXPECT_FALSE(getImpl(filepath).store(data));
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}
+
+TEST_F_S(Load, NoFileAvailable) {
+ EXPECT_EQ(getImpl().load(), std::vector<std::uint8_t> {});
+}
+
+TEST_F_S(Load, FileRead) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ const std::vector<std::uint8_t> data { 0x00, 0x01, 0x02, 0x04, 'S', 'O', 'M', 'E', ' ', 'D', 'A', 'T', 'A' };
+
+ {
+ std::ofstream file { filepath, std::ios_base::binary };
+ std::ranges::copy(data, std::ostreambuf_iterator<char> { file });
+ }
+
+ EXPECT_EQ(getImpl(filepath).load(), data);
+}
+
+TEST_F_S(Clear, NoFileAvailable) {
+ EXPECT_TRUE(getImpl().clear());
+}
+
+TEST_F_S(Clear, FileRemoved) {
+ const std::filesystem::path filepath { "myfile.ext" };
+ {
+ std::ofstream file { filepath };
+ file << "some data";
+ }
+
+ EXPECT_TRUE(std::filesystem::exists(filepath));
+ EXPECT_TRUE(getImpl(filepath).clear());
+ EXPECT_FALSE(std::filesystem::exists(filepath));
+}