repositoryIfTestSuite.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TEST_REPOSITORYIFTESTSUITE_HPP
#define RTCTK_COMPONENTFRAMEWORK_TEST_REPOSITORYIFTESTSUITE_HPP
 
#include <rtctk/componentFramework/repositoryIf.hpp>
#include <rtctk/componentFramework/typeTraits.hpp>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <fmt/format.h>
 
#include <exception>
#include <future>
#include <stdexcept>
#include <type_traits>
 
// ---------------- User defined types for testing type handling -----------------
// The following forward declarations are used with specialisations of UserTypeHandler to allow
// testing RepositoryIf methods such as CreateDataPoint, ReadDataPoint, WriteDataPoint, etc. that
// will actually trigger exceptions when invoking certain UserTypeHandler methods.
// To minimise boiler-plate code, some helper functions are implemented in these "type" classes that
// are called within the UserTypeHandler specialisation. These methods serve no further purpose than
// this and do not form part of a user defined type API.
namespace rtctk::componentFramework::test {
 
class TestingUserTypeBase {
public:
    TestingUserTypeBase() = default;
    explicit TestingUserTypeBase(std::string value) : m_value(std::move(value)) {
    }
    virtual RtcVectorUInt64 GetShape() const {
        return {m_value.size()};
    }
 
    virtual gsl::span<char> MakeSpan() {
        return gsl::span<char>{m_value.data(), m_value.size()};
    };
    virtual gsl::span<const char> MakeSpan() const {
        return gsl::span<const char>{m_value.data(), m_value.size()};
    };
 
    virtual bool ResizeBuffer(const RtcVectorUInt64& shape) {
        if (shape.size() == 1) {
            m_value.resize(shape[0]);
        } else {
            m_value.resize(detail::GetNumOfElements(shape));
        }
        return true;
    };
 
    std::string m_value;
};
 
class ThrowInGetShape : public TestingUserTypeBase {
public:
    using TestingUserTypeBase::TestingUserTypeBase;
    RtcVectorUInt64 GetShape() const override {
        throw std::runtime_error("GetShape");
    }
};
 
class ThrowInMakeSpan : public TestingUserTypeBase {
public:
    using TestingUserTypeBase::TestingUserTypeBase;
    gsl::span<char> MakeSpan() override {
        throw std::runtime_error("MakeSpan");
    };
    gsl::span<const char> MakeSpan() const override {
        throw std::runtime_error("MakeSpan");
    };
};
 
class ThrowInResizeBuffer : public TestingUserTypeBase {
public:
    using TestingUserTypeBase::TestingUserTypeBase;
    bool ResizeBuffer(const RtcVectorUInt64& shape) override {
        throw std::runtime_error("ResizeBuffer");
    };
};
 
}  // namespace rtctk::componentFramework::test
 
namespace rtctk::componentFramework::detail {
// Register handlers for custom types that trigger exceptions for unit testing.
template <>
struct UserTypeHandler<rtctk::componentFramework::test::ThrowInMakeSpan> {
    using BufferType = test::ThrowInMakeSpan;
    using ElementType = char;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return buffer.GetShape();
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return buffer.MakeSpan();
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return buffer.MakeSpan();
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        return buffer.ResizeBuffer(shape);
    }
};
 
template <>
struct UserTypeHandler<rtctk::componentFramework::test::ThrowInResizeBuffer> {
    using BufferType = test::ThrowInResizeBuffer;
    using ElementType = std::remove_cv_t<typename std::string::value_type>;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return buffer.GetShape();
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return buffer.MakeSpan();
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return buffer.MakeSpan();
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        return buffer.ResizeBuffer(shape);
    }
};
 
template <>
struct UserTypeHandler<rtctk::componentFramework::test::ThrowInGetShape> {
    using BufferType = test::ThrowInGetShape;
    using ElementType = std::remove_cv_t<typename std::string::value_type>;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return buffer.GetShape();
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return buffer.MakeSpan();
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return buffer.MakeSpan();
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        return buffer.ResizeBuffer(shape);
    }
};
 
}  // namespace rtctk::componentFramework::detail
 
namespace rtctk::componentFramework::test {
 
using testing::ContainerEq;
using testing::IsEmpty;
using testing::UnorderedElementsAreArray;
 
static std::shared_ptr<RepositoryIf> MakeRepository();
 
template <typename T>
class RepositoryIfTestSuite : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        dp_paths.clear();
        for (unsigned i = 0; i < 10; i++) {
            std::string name = fmt::format("/test/datapoint_{:0>2}", i);
            dp_paths.emplace_back(name);
        }
    }
 
    void TearDown() override {
        for (const auto& path : dp_paths) {
            if (repo->DataPointExists(path)) {
                repo->DeleteDataPoint(path);
            }
        }
        dp_paths.clear();
    }
 
    T MakeSomeTestValue() {
        if constexpr (std::is_same_v<T, std::byte>) {
            return std::byte{43};
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            return {std::byte{42}, std::byte{43}};
        } else if constexpr (std::is_same_v<T, RtcBool>) {
            return false;
        } else if constexpr (std::is_same_v<T, RtcString>) {
            return "foo";
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            return {1, 3, {false, true, false}};
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            return {false, false, false};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {1, 2, {"foo", "bar"}};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {"goo", "gar"};
        } else if constexpr (std::is_arithmetic_v<T>) {
            return 42;
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {1, 2, {42, 44}};
        } else {
            return {42, 43};
        }
    }
 
    T MakeOtherTestValue() {
        // Make sure the values and shapes are different for the test value returned by this method
        // compared to those that are in MakeSomeTestValue.
        if constexpr (std::is_same_v<T, std::byte>) {
            return std::byte{43};
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            return {std::byte{43}, std::byte{44}, std::byte{45}};
        } else if constexpr (std::is_same_v<T, RtcBool>) {
            return true;
        } else if constexpr (std::is_same_v<T, RtcString>) {
            return "barfoo";
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            return {2, 2, {true, false, true, false}};
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            return {true, true, true, true};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {1, 3, {"foo", "bar", "baz"}};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {"goo", "gar", "gaz"};
        } else if constexpr (std::is_arithmetic_v<T>) {
            return 43;
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {1, 3, {43, 44, 45}};
        } else {
            return {43, 44, 45};
        }
    }
 
    template <typename U>
    size_t GetExpectedSize(const U& value) {
        if constexpr (std::is_same_v<U, std::byte>) {
            return sizeof(value);
        } else if constexpr (std::is_arithmetic_v<U>) {
            return sizeof(value);
        } else {
            auto val = MakeSomeTestValue();
            return val.size();
        }
    }
 
protected:
    std::vector<DataPointPath> dp_paths;
    std::shared_ptr<RepositoryIf> repo;
};

 
template <typename T>
using BasicOperation = RepositoryIfTestSuite<T>;
 
// Define the fundamental type-set of datapoint types that must be supported for basic operations.
using TypeSetForBasicOperation = ::testing::Types<RtcBool,
                                                  RtcInt8,
                                                  RtcInt16,
                                                  RtcInt32,
                                                  RtcInt64,
                                                  RtcUInt8,
                                                  RtcUInt16,
                                                  RtcUInt32,
                                                  RtcUInt64,
                                                  RtcFloat,
                                                  RtcDouble,
                                                  RtcString,
                                                  RtcBinary,
                                                  RtcVectorBool,
                                                  RtcVectorInt8,
                                                  RtcVectorInt16,
                                                  RtcVectorInt32,
                                                  RtcVectorInt64,
                                                  RtcVectorUInt8,
                                                  RtcVectorUInt16,
                                                  RtcVectorUInt32,
                                                  RtcVectorUInt64,
                                                  RtcVectorFloat,
                                                  RtcVectorDouble,
                                                  RtcVectorString,
                                                  RtcMatrixBool,
                                                  RtcMatrixInt8,
                                                  RtcMatrixInt16,
                                                  RtcMatrixInt32,
                                                  RtcMatrixInt64,
                                                  RtcMatrixUInt8,
                                                  RtcMatrixUInt16,
                                                  RtcMatrixUInt32,
                                                  RtcMatrixUInt64,
                                                  RtcMatrixFloat,
                                                  RtcMatrixDouble,
                                                  RtcMatrixString>;
 
// define different test sets
TYPED_TEST_SUITE(BasicOperation, TypeSetForBasicOperation);
 
TYPED_TEST(BasicOperation, DataPointExistanceConsistency) {
    // Checks the following:
    // - That a datapoint can be created with the datapoint type given as a template argument.
    // - Can test for datapoint existance without exceptions and that the answer is consistent.
    auto path1 = this->dp_paths[0];
    auto path2 = this->dp_paths[1];
    auto& repo = *this->repo;
    bool exists = false;
 
    // Check that no datapoints exist initially, including two dummy ones at different path levels.
    // Checking the dummy datapoints with different path levels is an additional sanity check in
    // case there is a bug related to handling path hierarchies in the adapter.
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path1); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path2); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/test/subdir/dummy"_dppath); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/dummy"_dppath); });
    EXPECT_EQ(exists, false);
 
    // Create first datapoint and check that only the created path exists.
    repo.template CreateDataPoint<TypeParam>(path1);
 
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path1); });
    EXPECT_EQ(exists, true);
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path2); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/test/subdir/dummy"_dppath); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/dummy"_dppath); });
    EXPECT_EQ(exists, false);
 
    // Create the second datapoint and check that they both exist.
    repo.template CreateDataPoint<TypeParam>(path2);
 
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path1); });
    EXPECT_EQ(exists, true);
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path2); });
    EXPECT_EQ(exists, true);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/test/subdir/dummy"_dppath); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/dummy"_dppath); });
    EXPECT_EQ(exists, false);
 
    // Now delete the first datapoint and see that only the second exists.
    ASSERT_NO_THROW({ repo.DeleteDataPoint(path1); });
 
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path1); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path2); });
    EXPECT_EQ(exists, true);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/test/subdir/dummy"_dppath); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/dummy"_dppath); });
    EXPECT_EQ(exists, false);
 
    // Delete also the second datapoint and see that no datapoints are marked as existing.
    ASSERT_NO_THROW({ repo.DeleteDataPoint(path2); });
 
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path1); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists(path2); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/test/subdir/dummy"_dppath); });
    EXPECT_EQ(exists, false);
    EXPECT_NO_THROW({ exists = repo.DataPointExists("/dummy"_dppath); });
    EXPECT_EQ(exists, false);
}
 
TYPED_TEST(BasicOperation, DataPointCreationAndDeletion) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
    TypeParam read_value;
 
    EXPECT_NO_THROW({ repo.DataPointExists(path); });
 
    ASSERT_FALSE(repo.DataPointExists(path));
 
    repo.CreateDataPoint(path, create_value);
    ASSERT_TRUE(repo.DataPointExists(path));
 
    repo.ReadDataPoint(path, read_value);
    ASSERT_EQ(create_value, read_value);
 
    repo.DeleteDataPoint(path);
    ASSERT_FALSE(repo.DataPointExists(path));
 
    // creating again to test that recreating a previously deleted datapoint also works
    repo.CreateDataPoint(path, create_value);
    ASSERT_TRUE(repo.DataPointExists(path));
}
 
TYPED_TEST(BasicOperation, DataPointWriteAndRead) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
    auto write_value = this->MakeOtherTestValue();
    TypeParam read_value;
 
    repo.CreateDataPoint(path, create_value);
 
    repo.WriteDataPoint(path, write_value);
    repo.ReadDataPoint(path, read_value);
    ASSERT_EQ(write_value, read_value);
 
    // writing again to test a subsequent write
    repo.WriteDataPoint(path, create_value);
    repo.ReadDataPoint(path, read_value);
    ASSERT_EQ(create_value, read_value);
}
 
TYPED_TEST(BasicOperation, DataPointWriteAndReadConstValue) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    const auto create_value = this->MakeSomeTestValue();
    const auto write_value = this->MakeOtherTestValue();
    TypeParam read_value;
 
    repo.CreateDataPoint(path, create_value);
 
    repo.WriteDataPoint(path, write_value);
    repo.ReadDataPoint(path, read_value);
    ASSERT_EQ(write_value, read_value);
 
    // writing again to test a subsequent write
    repo.WriteDataPoint(path, create_value);
    repo.ReadDataPoint(path, read_value);
    ASSERT_EQ(create_value, read_value);
}
 
TYPED_TEST(BasicOperation, DataPointSetAndGet) {
    auto path = this->dp_paths[0];
    RepositoryIf& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
    auto write_value = this->MakeOtherTestValue();
 
    repo.CreateDataPoint(path, create_value);
    repo.SetDataPoint(path, write_value);
 
    ASSERT_EQ(write_value, repo.GetDataPoint<TypeParam>(path));
 
    ASSERT_TRUE(repo.TryGetDataPoint<TypeParam>(path).has_value());
    ASSERT_EQ(write_value, repo.TryGetDataPoint<TypeParam>(path).value());
 
    ASSERT_FALSE(repo.TryGetDataPoint<TypeParam>("/non/existing/dp"_dppath).has_value());
}
 
TYPED_TEST(BasicOperation, DataPointTypeQuery) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
 
    repo.CreateDataPoint(path, create_value);
 
    const auto& type = repo.GetDataPointType(path);
 
    EXPECT_EQ(type, typeid(TypeParam));
}
 
TYPED_TEST(BasicOperation, DataPointSizeQuery) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
    auto create_value_size = this->GetExpectedSize(create_value);
 
    repo.CreateDataPoint(path, create_value);
    ASSERT_EQ(repo.GetDataPointSize(path), create_value_size);
}
 
TYPED_TEST(BasicOperation, DataPointShapeQuery) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
 
    repo.CreateDataPoint(path, create_value);
    auto shape = repo.GetDataPointShape(path);
 
    if constexpr (std::is_same_v<TypeParam, std::byte>) {
        ASSERT_TRUE(shape.empty());
    } else if constexpr (std::is_arithmetic_v<TypeParam>) {
        ASSERT_TRUE(shape.empty());
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        ASSERT_EQ(shape.size(), 2);
        ASSERT_EQ(shape[0], create_value.GetNrows());
        ASSERT_EQ(shape[1], create_value.GetNcols());
    } else if constexpr (IS_VECTOR_TYPE<TypeParam>) {
        ASSERT_EQ(shape.size(), 1);
        ASSERT_EQ(shape[0], create_value.size());
    } else if constexpr (std::is_same_v<TypeParam, RtcString>) {
        ASSERT_EQ(shape.size(), 1);
        ASSERT_EQ(shape[0], create_value.size());
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
}
 
TYPED_TEST(BasicOperation, RequestApiCommonUsage) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    {
        auto create_value = this->MakeSomeTestValue();
        auto write_value = this->MakeOtherTestValue();
        TypeParam read_value;
        bool exists = false;
 
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, create_value);
        req.DataPointExists(path, exists);
        req.WriteDataPoint(path, write_value);
        req.ReadDataPoint(path, read_value);
        repo.SendRequest(req).Wait();
 
        ASSERT_EQ(exists, true);
        ASSERT_EQ(write_value, read_value);
    }
 
    {
        bool exists = false;
        RepositoryIf::BatchRequest req;
 
        req.DeleteDataPoint(path);
        req.DataPointExists(path, exists);
        repo.SendRequest(req).Wait();
 
        ASSERT_EQ(exists, false);
    }
}
 
TYPED_TEST(BasicOperation, RequestApiCommonUsageConstValue) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    {
        const auto create_value = this->MakeSomeTestValue();
        const auto write_value = this->MakeOtherTestValue();
        TypeParam read_value;
        bool exists = false;
 
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, create_value);
        req.DataPointExists(path, exists);
        req.WriteDataPoint(path, write_value);
        req.ReadDataPoint(path, read_value);
        repo.SendRequest(req).Wait();
 
        ASSERT_EQ(exists, true);
        ASSERT_EQ(write_value, read_value);
    }
 
    {
        bool exists = false;
        RepositoryIf::BatchRequest req;
 
        req.DeleteDataPoint(path);
        req.DataPointExists(path, exists);
        repo.SendRequest(req).Wait();
 
        ASSERT_EQ(exists, false);
    }
}
 
TYPED_TEST(BasicOperation, MultiWrite) {
    auto& repo = *this->repo;
    auto path_1 = this->dp_paths[0];
    auto path_2 = this->dp_paths[1];
    auto create_value_1 = this->MakeSomeTestValue();
    auto create_value_2 = this->MakeOtherTestValue();
    auto write_value_1 = create_value_2;  // NOLINT(performance-unnecessary-copy-initialization)
    auto write_value_2 = create_value_1;  // NOLINT(performance-unnecessary-copy-initialization)
    TypeParam read_value_1;
    TypeParam read_value_2;
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path_1, create_value_1);
        req.CreateDataPoint(path_2, create_value_2);
        repo.SendRequest(req).Wait();
    }
 
    repo.WriteDataPoints(path_1, write_value_1, path_2, write_value_2);
 
    {
        RepositoryIf::BatchRequest req;
        req.ReadDataPoint(path_1, read_value_1);
        req.ReadDataPoint(path_2, read_value_2);
        repo.SendRequest(req).Wait();
    }
 
    ASSERT_EQ(read_value_1, write_value_1);
    ASSERT_EQ(read_value_2, write_value_2);
}
 
TYPED_TEST(BasicOperation, MultiRead) {
    auto& repo = *this->repo;
    auto path_1 = this->dp_paths[0];
    auto path_2 = this->dp_paths[1];
    auto create_value_1 = this->MakeSomeTestValue();
    auto create_value_2 = this->MakeOtherTestValue();
    TypeParam read_value_1;
    TypeParam read_value_2;
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path_1, create_value_1);
        req.CreateDataPoint(path_2, create_value_2);
        repo.SendRequest(req).Wait();
    }
 
    repo.ReadDataPoints(path_1, read_value_1, path_2, read_value_2);
 
    ASSERT_EQ(read_value_1, create_value_1);
    ASSERT_EQ(read_value_2, create_value_2);
}
 
TYPED_TEST(BasicOperation, SetAndGetWithStdAny) {
    auto path = this->dp_paths[0];
    RepositoryIf& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
    auto write_value = this->MakeOtherTestValue();
    std::any any_write_value = write_value;
 
    repo.CreateDataPoint(path, create_value);
    repo.SetDataPoint(path, any_write_value);
 
    {
        std::any any_read_value = repo.GetDataPoint<std::any>(path);
        TypeParam& read_value = std::any_cast<TypeParam&>(any_read_value);
        EXPECT_EQ(write_value, read_value);
    }
 
    {
        ASSERT_TRUE(repo.TryGetDataPoint<std::any>(path).has_value());
 
        std::any any_read_value = repo.TryGetDataPoint<std::any>(path).value();
        TypeParam& read_value = std::any_cast<TypeParam&>(any_read_value);
        EXPECT_EQ(write_value, read_value);
    }
}
 
TYPED_TEST(BasicOperation, WriteReadWithStdAny) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    {
        auto create_value = this->MakeSomeTestValue();
        std::any any_create_value = create_value;
        repo.CreateDataPoint(path, any_create_value);
 
        std::any any_read_value;
        repo.ReadDataPoint(path, any_read_value);
        TypeParam& read_value = std::any_cast<TypeParam&>(any_read_value);
        EXPECT_EQ(create_value, read_value);
    }
 
    {
        auto write_value = this->MakeOtherTestValue();
        std::any any_write_value = write_value;
        repo.WriteDataPoint(path, any_write_value);
 
        std::any any_read_value;
        repo.ReadDataPoint(path, any_read_value);
        TypeParam& read_value = std::any_cast<TypeParam&>(any_read_value);
        EXPECT_EQ(write_value, read_value);
    }
}
 
TYPED_TEST(BasicOperation, MultiWriteWithStdAny) {
    auto& repo = *this->repo;
    auto path_1 = this->dp_paths[0];
    auto path_2 = this->dp_paths[1];
    auto create_value_1 = this->MakeSomeTestValue();
    auto create_value_2 = this->MakeOtherTestValue();
    auto write_value_1 = create_value_2;  // NOLINT(performance-unnecessary-copy-initialization)
    auto write_value_2 = create_value_1;  // NOLINT(performance-unnecessary-copy-initialization)
    TypeParam read_value_1;
    TypeParam read_value_2;
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path_1, create_value_1);
        req.CreateDataPoint(path_2, create_value_2);
        repo.SendRequest(req).Wait();
    }
 
    std::any any_write_value_1 = write_value_1;
    std::any any_write_value_2 = write_value_2;
    repo.WriteDataPoints(path_1, any_write_value_1, path_2, any_write_value_2);
 
    {
        RepositoryIf::BatchRequest req;
        req.ReadDataPoint(path_1, read_value_1);
        req.ReadDataPoint(path_2, read_value_2);
        repo.SendRequest(req).Wait();
    }
 
    EXPECT_EQ(read_value_1, write_value_1);
    EXPECT_EQ(read_value_2, write_value_2);
}
 
TYPED_TEST(BasicOperation, MultiReadWithStdAny) {
    auto& repo = *this->repo;
    auto path_1 = this->dp_paths[0];
    auto path_2 = this->dp_paths[1];
    auto create_value_1 = this->MakeSomeTestValue();
    auto create_value_2 = this->MakeOtherTestValue();
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path_1, create_value_1);
        req.CreateDataPoint(path_2, create_value_2);
        repo.SendRequest(req).Wait();
    }
 
    std::any any_read_value_1;
    std::any any_read_value_2;
    repo.ReadDataPoints(path_1, any_read_value_1, path_2, any_read_value_2);
 
    TypeParam& read_value_1 = std::any_cast<TypeParam&>(any_read_value_1);
    TypeParam& read_value_2 = std::any_cast<TypeParam&>(any_read_value_2);
    EXPECT_EQ(read_value_1, create_value_1);
    EXPECT_EQ(read_value_2, create_value_2);
}

 
template <typename T>
class AdvancedOperation : public RepositoryIfTestSuite<T> {
public:
    T MakeLargeTestValue() {
        if constexpr (std::is_same_v<T, RtcBinary>) {
            return T(5000, std::byte{43});
        } else if constexpr (std::is_same_v<T, RtcString>) {
            return std::string(5000, 'c');
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return T(500, 500, std::vector<std::string>(500 * 500, std::string("foo")));
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return T(5000, std::string("foo"));
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {500, 500, std::vector<typename T::value_type>(500 * 500, 42)};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return T(5000, 42);
        } else {
            return T(5000);
        }
    }
 
    RtcVectorUInt64 ExpectedLargeTestValueShape() {
        if constexpr (std::is_same_v<T, RtcBinary>) {
            return {5000};
        } else if constexpr (std::is_same_v<T, RtcString>) {
            return {5000};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {500, 500};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {5000};
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {500, 500};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {5000};
        } else {
            return {5000};
        }
    }
 
    T MakeSmallTestValue() {
        if constexpr (std::is_same_v<T, RtcBinary>) {
            return T(2, std::byte{42});
        } else if constexpr (std::is_same_v<T, RtcString>) {
            return std::string(2, 'b');
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return T(2, 2, std::vector<std::string>(2 * 2, std::string("goo")));
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return T(2, std::string("goo"));
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {2, 2, std::vector<typename T::value_type>(2 * 2, 43)};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return T(2, 43);
        } else {
            return T(2);
        }
    }
 
    RtcVectorUInt64 ExpectedSmallTestValueShape() {
        if constexpr (std::is_same_v<T, RtcBinary>) {
            return {2};
        } else if constexpr (std::is_same_v<T, RtcString>) {
            return {2};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {2, 2};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {2};
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {2, 2};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {2};
        } else {
            return {2};
        }
    }
 
    T MakeCreateValueForPartialIo() {
        if constexpr (std::is_same_v<T, RtcString>) {
            return "0123456789abcdef";
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            // clang-format off
            return { std::byte{1},  std::byte{2},  std::byte{3},  std::byte{4},
                     std::byte{5},  std::byte{6},  std::byte{7},  std::byte{8},
                     std::byte{9}, std::byte{10}, std::byte{11}, std::byte{12},
                    std::byte{13}, std::byte{14}, std::byte{15}, std::byte{16}};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            // clang-format off
            return {4, 4, { true,  true, false, false,
                           false, false,  true, false,
                           false, false, false,  true,
                           false, false, false, false}};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            // clang-format off
            return {4, 4, { "1",  "2",  "3",  "4",
                            "5",  "6",  "7",  "8",
                            "9", "10", "11", "12",
                           "13", "14", "15", "16"}};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            // clang-format off
            return {true, false, true, false, true, false, true, false,
                    true, false, true, false, true, false, true, false};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            // clang-format off
            return {"1",  "2",  "3",  "4",  "5",  "6",  "7",  "8",
                    "9", "10", "11", "12", "13", "14", "15", "16"};
            // clang-format on
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            // clang-format off
            return {4, 4, { 1,  2,  3,  4,
                            5,  6,  7,  8,
                            9, 10, 11, 12,
                           13, 14, 15, 16}};
            // clang-format on
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        } else {
            static_assert(false, "Should never enter here. There is a bug in the test code.");
        }
    }
 
    T MakeWriteValueForPartialIo() {
        if constexpr (std::is_same_v<T, RtcString>) {
            return "abcd";
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            return {std::byte{12}, std::byte{13}, std::byte{14}, std::byte{15}};
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            return {1, 4, {false, false, true, true}};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {1, 4, {"12", "13", "14", "15"}};
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            return {true, true, true, true};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {"12", "13", "14", "15"};
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {1, 4, {12, 13, 14, 15}};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {12, 13, 14, 15};
        } else {
            static_assert(false, "Should never enter here. There is a bug in the test code.");
        }
    }
 
    T MakeExpectedResultValueForPartialWrite() {
        if constexpr (std::is_same_v<T, RtcString>) {
            return "abcd456789abcdef";
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            // clang-format off
            return {std::byte{12}, std::byte{13}, std::byte{14}, std::byte{15},
                     std::byte{5},  std::byte{6},  std::byte{7},  std::byte{8},
                     std::byte{9}, std::byte{10}, std::byte{11}, std::byte{12},
                    std::byte{13}, std::byte{14}, std::byte{15}, std::byte{16}};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            // clang-format off
            return {4, 4, {false, false,  true,  true,
                           false, false,  true, false,
                           false, false, false,  true,
                           false, false, false, false}};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            // clang-format off
            return {4, 4, {"12", "13", "14", "15",
                            "5",  "6",  "7",  "8",
                            "9", "10", "11", "12",
                           "13", "14", "15", "16"}};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            // clang-format off
            return {true,  true, true,  true, true, false, true, false,
                    true, false, true, false, true, false, true, false};
            // clang-format on
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            // clang-format off
            return {"12", "13", "14", "15",  "5",  "6",  "7",  "8",
                     "9", "10", "11", "12", "13", "14", "15", "16"};
            // clang-format on
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            // clang-format off
            return {4, 4, {12, 13, 14, 15,
                            5,  6,  7,  8,
                            9, 10, 11, 12,
                           13, 14, 15, 16}};
            // clang-format on
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {12, 13, 14, 15, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        } else {
            static_assert(false, "Should never enter here. There is a bug in the test code.");
        }
    }
 
    T MakeExpectedResultValueForPartialRead() {
        if constexpr (std::is_same_v<T, RtcString>) {
            return "0123";
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            return {std::byte{1}, std::byte{2}, std::byte{3}, std::byte{4}};
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            return {1, 4, {true, true, false, false}};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {1, 4, {"1", "2", "3", "4"}};
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            return {true, false, true, false};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {"1", "2", "3", "4"};
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {1, 4, {1, 2, 3, 4}};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {1, 2, 3, 4};
        } else {
            static_assert(false, "Should never enter here. There is a bug in the test code.");
        }
    }
 
    T MakeExpectedResultValueForPartialReadEnd() {
        if constexpr (std::is_same_v<T, RtcString>) {
            return "cdef";
        } else if constexpr (std::is_same_v<T, RtcBinary>) {
            return {std::byte{13}, std::byte{14}, std::byte{15}, std::byte{16}};
        } else if constexpr (std::is_same_v<T, RtcMatrixBool>) {
            return {1, 4, {false, false, false, false}};
        } else if constexpr (std::is_same_v<T, RtcMatrixString>) {
            return {1, 4, {"13", "14", "15", "16"}};
        } else if constexpr (std::is_same_v<T, RtcVectorBool>) {
            return {true, false, true, false};
        } else if constexpr (std::is_same_v<T, RtcVectorString>) {
            return {"13", "14", "15", "16"};
        } else if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            return {1, 4, {13, 14, 15, 16}};
        } else if constexpr (IS_VECTOR_TYPE<T>) {
            return {13, 14, 15, 16};
        } else {
            static_assert(false, "Should never enter here. There is a bug in the test code.");
        }
    }
 
    T MakeReadValueForPartialIo(const T& result_value) {
        T read_value;
        if constexpr (IS_MATRIX_BUFFER_TYPE<T>) {
            read_value.resize(result_value.GetNrows(), result_value.GetNcols());
        } else {
            read_value.resize(result_value.size());
        }
        return read_value;
    }
};
 
using TypeSetAdvancedOperation = ::testing::Types<RtcString,
                                                  RtcBinary,
                                                  RtcVectorBool,
                                                  RtcVectorInt8,
                                                  RtcVectorInt16,
                                                  RtcVectorInt32,
                                                  RtcVectorInt64,
                                                  RtcVectorUInt8,
                                                  RtcVectorUInt16,
                                                  RtcVectorUInt32,
                                                  RtcVectorUInt64,
                                                  RtcVectorFloat,
                                                  RtcVectorDouble,
                                                  RtcVectorString,
                                                  RtcMatrixBool,
                                                  RtcMatrixInt8,
                                                  RtcMatrixInt16,
                                                  RtcMatrixInt32,
                                                  RtcMatrixInt64,
                                                  RtcMatrixUInt8,
                                                  RtcMatrixUInt16,
                                                  RtcMatrixUInt32,
                                                  RtcMatrixUInt64,
                                                  RtcMatrixFloat,
                                                  RtcMatrixDouble,
                                                  RtcMatrixString>;
 
TYPED_TEST_SUITE(AdvancedOperation, TypeSetAdvancedOperation);
 
TYPED_TEST(AdvancedOperation, ModifiedDataPointShapeIsDetected) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
    auto create_value = this->MakeSomeTestValue();
    auto write_value = this->MakeOtherTestValue();
 
    repo.CreateDataPoint(path, create_value);
    auto create_shape = repo.GetDataPointShape(path);
    repo.WriteDataPoint(path, write_value);
    auto write_shape = repo.GetDataPointShape(path);
 
    EXPECT_NE(create_shape, write_shape);
}
 
TYPED_TEST(AdvancedOperation, CreateAndReadLargeData) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    auto create_value = this->MakeLargeTestValue();
    TypeParam read_value;
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.ReadDataPoint(path, read_value);
    repo.SendRequest(req).Wait();
 
    ASSERT_EQ(read_value, create_value);
}
 
TYPED_TEST(AdvancedOperation, ResizeFromSmallToLarge) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    auto create_value = this->MakeSmallTestValue();
    auto write_value = this->MakeLargeTestValue();
    auto expected_shape = this->ExpectedLargeTestValueShape();
    TypeParam read_value;
 
    auto val = this->MakeLargeTestValue();
    EXPECT_EQ(val, write_value);
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.WriteDataPoint(path, write_value);
    req.ReadDataPoint(path, read_value);
    repo.SendRequest(req).Wait();
    EXPECT_EQ(read_value, write_value);
 
    auto shape = repo.GetDataPointShape(path);
    EXPECT_EQ(shape, expected_shape);
}
 
TYPED_TEST(AdvancedOperation, ResizeFromLargeToSmall) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    auto create_value = this->MakeLargeTestValue();
    auto write_value = this->MakeSmallTestValue();
    auto expected_shape = this->ExpectedSmallTestValueShape();
    TypeParam read_value;
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.WriteDataPoint(path, write_value);
    req.ReadDataPoint(path, read_value);
    repo.SendRequest(req).Wait();
    ASSERT_EQ(read_value, write_value);
 
    auto shape = repo.GetDataPointShape(path);
    EXPECT_EQ(shape, expected_shape);
}
 
TYPED_TEST(AdvancedOperation, ResizeFromOneToEmpty) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    TypeParam create_value;
    TypeParam write_value;
    TypeParam read_value_1;
    TypeParam read_value_2;
    RtcVectorUInt64 expected_shape;
 
    if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
        create_value.resize(1, std::byte{42});
        expected_shape = {0};
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
        create_value.resize(1, 1, "foo");
        expected_shape = {0, 0};
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
        create_value.resize(1, "foo");
        expected_shape = {0};
    } else if constexpr (std::is_same_v<TypeParam, RtcString>) {
        create_value = std::string(1, 'c');
        expected_shape = {0};
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        create_value.resize(1, 1, 42);
        expected_shape = {0, 0};
    } else if constexpr (IS_VECTOR_TYPE<TypeParam>) {
        create_value.resize(1, 42);
        expected_shape = {0};
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.ReadDataPoint(path, read_value_1);
    req.WriteDataPoint(path, write_value);
    req.ReadDataPoint(path, read_value_2);
    repo.SendRequest(req).Wait();
    ASSERT_EQ(read_value_1, create_value);
    ASSERT_EQ(read_value_2, write_value);
 
    auto shape = repo.GetDataPointShape(path);
    EXPECT_EQ(shape, expected_shape);
}
 
TYPED_TEST(AdvancedOperation, ResizeFromLargeToEmpty) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    TypeParam create_value;
    TypeParam write_value;
    TypeParam read_value;
    RtcVectorUInt64 expected_shape;
 
    if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
        create_value.resize(5000, std::byte{42});
        expected_shape = {0};
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
        create_value.resize(500, 500, "foo");
        expected_shape = {0, 0};
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
        create_value.resize(5000, "foo");
        expected_shape = {0};
    } else if constexpr (std::is_same_v<TypeParam, RtcString>) {
        create_value = std::string(5000, 'c');
        expected_shape = {0};
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        create_value.resize(500, 500, 42);
        expected_shape = {0, 0};
    } else if constexpr (IS_VECTOR_TYPE<TypeParam>) {
        create_value.resize(5000, 42);
        expected_shape = {0};
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.WriteDataPoint(path, write_value);
    req.ReadDataPoint(path, read_value);
    repo.SendRequest(req).Wait();
    ASSERT_EQ(read_value, write_value);
 
    auto shape = repo.GetDataPointShape(path);
    EXPECT_EQ(shape, expected_shape);
}
 
TYPED_TEST(AdvancedOperation, PartialWritePattern) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    TypeParam create_value = this->MakeCreateValueForPartialIo();
    TypeParam write_value = this->MakeWriteValueForPartialIo();
    TypeParam read_value;
    TypeParam result_value = this->MakeExpectedResultValueForPartialWrite();
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.PartialWriteDataPoint(path, write_value, 0, 4, 0);
    req.ReadDataPoint(path, read_value);
    repo.SendRequest(req).Wait();
 
    EXPECT_EQ(read_value, result_value);
}
 
TYPED_TEST(AdvancedOperation, PartialReadPattern) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    {
        // partial read first 4 elements
        TypeParam create_value = this->MakeCreateValueForPartialIo();
        TypeParam result_value = this->MakeExpectedResultValueForPartialRead();
        TypeParam read_value = this->MakeReadValueForPartialIo(result_value);
 
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, create_value);
        req.PartialReadDataPoint(path, read_value, 0, 4, 0);
        repo.SendRequest(req).Wait();
        EXPECT_EQ(read_value, result_value);
    }
 
    {
        // partial read last 4 elements
        TypeParam result_value = this->MakeExpectedResultValueForPartialReadEnd();
        TypeParam read_value = this->MakeReadValueForPartialIo(result_value);
 
        RepositoryIf::BatchRequest req;
        req.PartialReadDataPoint(path, read_value, 12, 16, 0);
        repo.SendRequest(req).Wait();
        EXPECT_EQ(read_value, result_value);
    }
}
 
TYPED_TEST(AdvancedOperation, PartialWritePatternWithStdAny) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    TypeParam create_value = this->MakeCreateValueForPartialIo();
    std::any any_write_value = this->MakeWriteValueForPartialIo();
    TypeParam read_value;
    TypeParam result_value = this->MakeExpectedResultValueForPartialWrite();
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.PartialWriteDataPoint(path, any_write_value, 0, 4, 0);
    req.ReadDataPoint(path, read_value);
    repo.SendRequest(req).Wait();
 
    EXPECT_EQ(read_value, result_value);
}
 
TYPED_TEST(AdvancedOperation, PartialReadPatternWithStdAny) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    TypeParam create_value = this->MakeCreateValueForPartialIo();
    TypeParam result_value = this->MakeExpectedResultValueForPartialRead();
    std::any any_read_value = this->MakeReadValueForPartialIo(result_value);
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.PartialReadDataPoint(path, any_read_value, 0, 4, 0);
    repo.SendRequest(req).Wait();
 
    TypeParam& read_value = std::any_cast<TypeParam&>(any_read_value);
    EXPECT_EQ(read_value, result_value);
}
 
template <typename T>
struct TypeMap {};
 
template <>
struct TypeMap<RtcString> {
    using BufferType = RtcString;
    using SpanType = gsl::span<char>;
    using ConstSpanType = gsl::span<const char>;
};
 
template <typename T, typename A>
struct TypeMap<MatrixBuffer<T, A>> {
    using BufferType = MatrixBuffer<T, A>;
    using SpanType = MatrixSpan<T>;
    using ConstSpanType = MatrixSpan<const T>;
};
 
template <typename T, typename A>
struct TypeMap<std::vector<T, A>> {
    using BufferType = std::vector<T, A>;
    using SpanType = gsl::span<T>;
    using ConstSpanType = gsl::span<const T>;
};
 
template <typename A>
struct TypeMap<std::vector<bool, A>> {
    using BufferType = boost::container::vector<bool, A>;
    using SpanType = gsl::span<bool>;
    using ConstSpanType = gsl::span<const bool>;
};
 
template <typename A>
struct TypeMap<MatrixBuffer<bool, A>> {
    using BufferType = boost::container::vector<bool, A>;
    using SpanType = MatrixSpan<bool>;
    using ConstSpanType = MatrixSpan<const bool>;
};
 
TYPED_TEST(AdvancedOperation, SpanAccess) {
    auto path1 = this->dp_paths[0];
    auto path2 = this->dp_paths[1];
    auto& repo = *this->repo;
 
    using BufferType = typename TypeMap<TypeParam>::BufferType;
    BufferType create_value;
    BufferType write_value;
    BufferType read_value;
 
    if constexpr (std::is_same_v<TypeParam, RtcString>) {
        create_value = "abcd";
        write_value = "1234";
        read_value.resize(create_value.size());
    } else if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
        create_value = {std::byte{1}, std::byte{2}, std::byte{3}, std::byte{4}};
        write_value = {std::byte{11}, std::byte{12}, std::byte{13}, std::byte{14}};
        read_value.resize(create_value.size());
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixBool>) {
        create_value = {true, true, false, false};
        write_value = {false, false, true, true};
        read_value.resize(create_value.size());
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
        create_value = {2, 2, {"aa", "bb", "cc", "dd"}};
        write_value = {2, 2, {"00", "11", "22", "33"}};
        read_value.resize(create_value.GetNrows(), create_value.GetNcols());
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        create_value = {2, 2, {1, 2, 3, 4}};
        write_value = {2, 2, {11, 12, 13, 14}};
        read_value.resize(create_value.GetNrows(), create_value.GetNcols());
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorBool>) {
        create_value = {true, false, true, false};
        write_value = {false, true, false, true};
        read_value.resize(create_value.size());
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
        create_value = {"aa", "bb", "cc", "dd"};
        write_value = {"00", "11", "22", "33"};
        read_value.resize(create_value.size());
    } else if constexpr (IS_VECTOR_TYPE<TypeParam>) {
        create_value = {1, 2, 3, 4};
        write_value = {11, 12, 13, 14};
        read_value.resize(create_value.size());
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
 
    using SpanT = typename TypeMap<TypeParam>::SpanType;
    using ConstSpanT = typename TypeMap<TypeParam>::ConstSpanType;
    SpanT create_span;
    ConstSpanT create_const_span;
    SpanT write_span;
    ConstSpanT write_const_span;
    SpanT read_span;
 
    if constexpr (std::is_same_v<TypeParam, RtcMatrixBool>) {
        create_span = SpanT(2, 2, create_value);
        create_const_span = ConstSpanT(2, 2, create_value);
        write_span = SpanT(2, 2, write_value);
        write_const_span = ConstSpanT(2, 2, write_value);
        read_span = SpanT(2, 2, read_value);
    } else {
        create_span = SpanT(create_value);
        create_const_span = ConstSpanT(create_value);
        write_span = SpanT(write_value);
        write_const_span = ConstSpanT(write_value);
        read_span = SpanT(read_value);
    }
 
    // Create and write using non-const version of the spans.
    repo.CreateDataPoint(path1, create_span);
    ASSERT_EQ(repo.GetDataPointType(path1), typeid(TypeParam));
 
    repo.ReadDataPoint(path1, read_span);
    ASSERT_THAT(read_value, ContainerEq(create_value));
 
    repo.WriteDataPoint(path1, write_span);
    repo.ReadDataPoint(path1, read_span);
    ASSERT_THAT(read_value, ContainerEq(write_value));
 
    // Attempt the creation and writing of the datapoint with a const version of the spans.
    repo.CreateDataPoint(path2, create_const_span);
    ASSERT_EQ(repo.GetDataPointType(path2), typeid(TypeParam));
 
    repo.ReadDataPoint(path2, read_span);
    ASSERT_THAT(read_value, ContainerEq(create_value));
 
    repo.WriteDataPoint(path2, write_const_span);
    repo.ReadDataPoint(path2, read_span);
    ASSERT_THAT(read_value, ContainerEq(write_value));
 
    if constexpr (std::is_same_v<TypeParam, RtcString>) {
        // For a string datapoints we check that we can also create and write to them using
        // read-only string views. The std::string_view can be thought of as a read-only span.
        auto path3 = this->dp_paths[2];
        std::string_view create_view = create_value;
        std::string_view write_view = write_value;
 
        repo.CreateDataPoint(path3, create_view);
        ASSERT_EQ(repo.GetDataPointType(path3), typeid(TypeParam));
 
        repo.ReadDataPoint(path3, read_value);
        ASSERT_THAT(read_value, ContainerEq(create_value));
 
        repo.WriteDataPoint(path3, write_view);
        repo.ReadDataPoint(path3, read_value);
        ASSERT_THAT(read_value, ContainerEq(write_value));
    }
}
 
TYPED_TEST(AdvancedOperation, StdArrayAccess) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    if constexpr (std::is_same_v<TypeParam, RtcString> or IS_VECTOR_TYPE<TypeParam>) {
        using ArrayType = std::array<typename TypeParam::value_type, 4>;
        ArrayType create_array;
        ArrayType write_array;
        ArrayType read_array;
        if constexpr (std::is_same_v<TypeParam, RtcString>) {
            create_array = {'a', 'b', 'c', 'd'};
            write_array = {'1', '2', '3', '4'};
        } else if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
            create_array = {std::byte{1}, std::byte{2}, std::byte{3}, std::byte{4}};
            write_array = {std::byte{11}, std::byte{12}, std::byte{13}, std::byte{14}};
        } else if constexpr (std::is_same_v<TypeParam, RtcVectorBool>) {
            create_array = {true, false, true, false};
            write_array = {false, true, false, true};
        } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
            create_array = {"aa", "bb", "cc", "dd"};
            write_array = {"00", "11", "22", "33"};
        } else {
            create_array = {1, 2, 3, 4};
            write_array = {11, 12, 13, 14};
        }
 
        repo.CreateDataPoint(path, create_array);
        ASSERT_EQ(repo.GetDataPointType(path), typeid(TypeParam));
 
        repo.ReadDataPoint(path, read_array);
        ASSERT_EQ(create_array, read_array);
 
        repo.WriteDataPoint(path, write_array);
        repo.ReadDataPoint(path, read_array);
        ASSERT_EQ(write_array, read_array);
 
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        using Row = std::array<typename TypeParam::value_type, 2>;
        using MatrixType = std::array<Row, 2>;
        MatrixType create_array;
        MatrixType write_array;
        MatrixType read_array;
        if constexpr (std::is_same_v<TypeParam, RtcMatrixBool>) {
            create_array = {Row{true, false}, Row{true, false}};
            write_array = {Row{false, true}, Row{false, true}};
        } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
            create_array = {Row{"aa", "bb"}, Row{"cc", "dd"}};
            write_array = {Row{"00", "11"}, Row{"22", "33"}};
        } else {
            create_array = {Row{1, 2}, Row{3, 4}};
            write_array = {Row{11, 12}, Row{13, 14}};
        }
 
        repo.CreateDataPoint(path, create_array);
        ASSERT_EQ(repo.GetDataPointType(path), typeid(TypeParam));
 
        repo.ReadDataPoint(path, read_array);
        ASSERT_EQ(create_array, read_array);
 
        repo.WriteDataPoint(path, write_array);
        repo.ReadDataPoint(path, read_array);
        ASSERT_EQ(write_array, read_array);
 
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
}
 
TYPED_TEST(AdvancedOperation, CStyleArrayAccess) {
    using testing::ElementsAreArray;
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    if constexpr (std::is_same_v<TypeParam, RtcString> or IS_VECTOR_TYPE<TypeParam>) {
        using ValueType = typename TypeParam::value_type;
        ValueType create_array[4];  // NOLINT(modernize-avoid-c-arrays)
        ValueType write_array[4];   // NOLINT(modernize-avoid-c-arrays)
        ValueType read_array[4];    // NOLINT(modernize-avoid-c-arrays)
        if constexpr (std::is_same_v<TypeParam, RtcString>) {
            create_array[0] = 'a';
            create_array[1] = 'b';
            create_array[2] = 'c';
            create_array[3] = 'd';
            write_array[0] = '1';
            write_array[1] = '2';
            write_array[2] = '3';
            write_array[3] = '4';
        } else if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
            create_array[0] = std::byte{1};
            create_array[1] = std::byte{2};
            create_array[2] = std::byte{3};
            create_array[3] = std::byte{4};
            write_array[0] = std::byte{11};
            write_array[1] = std::byte{12};
            write_array[2] = std::byte{13};
            write_array[3] = std::byte{14};
        } else if constexpr (std::is_same_v<TypeParam, RtcVectorBool>) {
            create_array[0] = true;
            create_array[1] = false;
            create_array[2] = false;
            create_array[3] = true;
            write_array[0] = false;
            write_array[1] = true;
            write_array[2] = true;
            write_array[3] = false;
        } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
            create_array[0] = "aa";
            create_array[1] = "bb";
            create_array[2] = "cc";
            create_array[3] = "dd";
            write_array[0] = "00";
            write_array[1] = "11";
            write_array[2] = "22";
            write_array[3] = "33";
        } else {
            create_array[0] = 1;
            create_array[1] = 2;
            create_array[2] = 3;
            create_array[3] = 4;
            write_array[0] = 11;
            write_array[1] = 12;
            write_array[2] = 13;
            write_array[3] = 14;
        }
 
        repo.CreateDataPoint(path, create_array);
        ASSERT_EQ(repo.GetDataPointType(path), typeid(TypeParam));
 
        repo.ReadDataPoint(path, read_array);
        gsl::span<ValueType, 4> create_span(std::begin(create_array), std::end(create_array));
        EXPECT_THAT(create_span, ElementsAreArray(std::begin(read_array), std::end(read_array)));
 
        repo.WriteDataPoint(path, write_array);
        repo.ReadDataPoint(path, read_array);
        gsl::span<ValueType, 4> write_span(std::begin(write_array), std::end(write_array));
        EXPECT_THAT(write_span, ElementsAreArray(std::begin(read_array), std::end(read_array)));
 
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        using ValueType = typename TypeParam::value_type;
        ValueType create_array[2][2];  // NOLINT(modernize-avoid-c-arrays)
        ValueType write_array[2][2];   // NOLINT(modernize-avoid-c-arrays)
        ValueType read_array[2][2];    // NOLINT(modernize-avoid-c-arrays)
        if constexpr (std::is_same_v<TypeParam, RtcMatrixBool>) {
            create_array[0][0] = true;
            create_array[0][1] = false;
            create_array[1][0] = false;
            create_array[1][1] = true;
            write_array[0][0] = false;
            write_array[0][1] = true;
            write_array[1][0] = true;
            write_array[1][1] = false;
        } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
            create_array[0][0] = "aa";
            create_array[0][1] = "bb";
            create_array[1][0] = "cc";
            create_array[1][1] = "dd";
            write_array[0][0] = "00";
            write_array[0][1] = "11";
            write_array[1][0] = "22";
            write_array[1][1] = "33";
        } else {
            create_array[0][0] = 1;
            create_array[0][1] = 2;
            create_array[1][0] = 3;
            create_array[1][1] = 4;
            write_array[0][0] = 11;
            write_array[0][1] = 12;
            write_array[1][0] = 13;
            write_array[1][1] = 14;
        }
        gsl::span<ValueType, 2 * 2> read_span(&read_array[0][0], 2 * 2);
 
        repo.CreateDataPoint(path, create_array);
        ASSERT_EQ(repo.GetDataPointType(path), typeid(TypeParam));
 
        repo.ReadDataPoint(path, read_array);
        gsl::span<ValueType, 2 * 2> create_span(&create_array[0][0], 2 * 2);
        EXPECT_THAT(create_span, ElementsAreArray(read_span.begin(), read_span.end()));
 
        repo.WriteDataPoint(path, write_array);
        repo.ReadDataPoint(path, read_array);
        gsl::span<ValueType, 2 * 2> write_span(&write_array[0][0], 2 * 2);
        EXPECT_THAT(write_span, ElementsAreArray(read_span.begin(), read_span.end()));
 
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
}

 
class Callbacks : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        path1 = "/foo"_dppath;
        path2 = "/bar"_dppath;
        link1 = "/link1"_dppath;
        link2 = "/link2"_dppath;
    }
 
    void TearDown() override {
        if (repo->DataPointExists(link1)) {
            repo->DeleteDataPoint(link1);
        }
        if (repo->DataPointExists(link2)) {
            repo->DeleteDataPoint(link2);
        }
        if (repo->DataPointExists(path1)) {
            repo->DeleteDataPoint(path1);
        }
        if (repo->DataPointExists(path2)) {
            repo->DeleteDataPoint(path2);
        }
    }
 
    template <typename T = RtcInt64>
    void SetupDataPoints(const T& initial_value = 0) {
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path1, initial_value);
        req.CreateDataPoint(path2, initial_value);
        repo->SendRequest(req).Wait();
    }
 
protected:
    std::shared_ptr<RepositoryIf> repo;
    DataPointPath path1;
    DataPointPath path2;
    DataPointPath link1;
    DataPointPath link2;
};
 
class MockCallbacks {
public:
    MOCK_METHOD(void, CreateCallback, (const DataPointPath& path));
    MOCK_METHOD(void, DeleteCallback, (const DataPointPath& path));
    MOCK_METHOD(void, ExistsCallback, (const DataPointPath& path));
    MOCK_METHOD(void, GetChildrenCallback, (const DataPointPath& path));
    MOCK_METHOD(void, WriteCallback, (const DataPointPath& path));
    MOCK_METHOD(void, ReadCallback, (const DataPointPath& path));
    MOCK_METHOD(void, PartialWriteCallback, (const DataPointPath& path));
    MOCK_METHOD(void, PartialReadCallback, (const DataPointPath& path));
    MOCK_METHOD(void, WriteMetaDataCallback, (const DataPointPath& path));
    MOCK_METHOD(void, ReadMetaDataCallback, (const DataPointPath& path));
    MOCK_METHOD(void, CreateSymlinkCallback, (const DataPointPath& path));
    MOCK_METHOD(void, UpdateSymlinkCallback, (const DataPointPath& path));
};
 
TEST_F(Callbacks, CreateDataPointCallback) {
    MockCallbacks callbacks;
 
    EXPECT_CALL(callbacks, CreateCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, CreateCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.CreateCallback(path); };
 
    int value1 = 1;
    int value2 = 2;
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path1, value1, std::nullopt, cb);
    req.CreateDataPoint(path2, value2, std::nullopt, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, DeleteDataPointCallback) {
    MockCallbacks callbacks;
 
    EXPECT_CALL(callbacks, DeleteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, DeleteCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.DeleteCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.DeleteDataPoint(path1, cb);
    req.DeleteDataPoint(path2, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, DataPointExistsCallback) {
    MockCallbacks callbacks;
    bool exists_1, exists_2;
 
    EXPECT_CALL(callbacks, ExistsCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ExistsCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.ExistsCallback(path); };
 
    RepositoryIf::BatchRequest req;
    req.DataPointExists(path1, exists_1, cb);
    req.DataPointExists(path2, exists_2, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, GetChildrenCallback) {
    MockCallbacks callbacks;
    std::pair<RepositoryIf::PathList, RepositoryIf::PathList> children_1, children_2;
 
    EXPECT_CALL(callbacks, GetChildrenCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, GetChildrenCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.GetChildrenCallback(path); };
 
    RepositoryIf::BatchRequest req;
    req.GetChildren(path1, children_1, true, cb);
    req.GetChildren(path2, children_2, false, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, WriteDataPointCallback) {
    MockCallbacks callbacks;
    RtcInt64 buffer1 = 1;
    RtcInt64 buffer2 = 2;
 
    EXPECT_CALL(callbacks, WriteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, WriteCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.WriteCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.WriteDataPoint(path1, buffer1, std::nullopt, cb);
    req.WriteDataPoint(path2, buffer2, std::nullopt, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, ReadDataPointCallback) {
    MockCallbacks callbacks;
    RtcInt64 buffer1, buffer2;
 
    EXPECT_CALL(callbacks, ReadCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ReadCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.ReadCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.ReadDataPoint(path1, buffer1, std::nullopt, cb);
    req.ReadDataPoint(path2, buffer2, std::nullopt, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, PartialWriteDataPointCallback) {
    MockCallbacks callbacks;
    RtcVectorInt64 buffer1{1, 2};
    RtcVectorInt64 buffer2{3, 4};
 
    EXPECT_CALL(callbacks, PartialWriteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, PartialWriteCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.PartialWriteCallback(path); };
 
    SetupDataPoints(RtcVectorInt64{0, 0});
 
    RepositoryIf::BatchRequest req;
    req.PartialWriteDataPoint(path1, buffer1, 0, 2, 0, std::nullopt, cb);
    req.PartialWriteDataPoint(path2, buffer2, 0, 2, 0, std::nullopt, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, PartialReadDataPointCallback) {
    MockCallbacks callbacks;
    RtcVectorInt64 buffer1{0, 0};
    RtcVectorInt64 buffer2{0, 0};
 
    EXPECT_CALL(callbacks, PartialReadCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, PartialReadCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.PartialReadCallback(path); };
 
    SetupDataPoints(RtcVectorInt64{1, 2});
 
    RepositoryIf::BatchRequest req;
    req.PartialReadDataPoint(path1, buffer1, 0, 2, 0, std::nullopt, cb);
    req.PartialReadDataPoint(path2, buffer2, 0, 2, 0, std::nullopt, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, WriteMetaDataCallback) {
    MockCallbacks callbacks;
    RepositoryIf::MetaData metadata1, metadata2;
    metadata1["comment"] = std::string{"foo"};
    metadata2["comment"] = std::string{"bar"};
 
    EXPECT_CALL(callbacks, WriteMetaDataCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, WriteMetaDataCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.WriteMetaDataCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.WriteMetaData(path1, metadata1, cb);
    req.WriteMetaData(path2, metadata2, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, ReadMetaDataCallback) {
    MockCallbacks callbacks;
    RepositoryIf::MetaData metadata1, metadata2;
 
    EXPECT_CALL(callbacks, ReadMetaDataCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ReadMetaDataCallback(path2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.ReadMetaDataCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.ReadMetaData(path1, metadata1, cb);
    req.ReadMetaData(path2, metadata2, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, CreateSymlinkCallback) {
    MockCallbacks callbacks;
 
    EXPECT_CALL(callbacks, CreateSymlinkCallback(link1)).Times(1);
    EXPECT_CALL(callbacks, CreateSymlinkCallback(link2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.CreateSymlinkCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.CreateSymlink(path1, "/link1"_dppath, cb);
    req.CreateSymlink(path2, "/link2"_dppath, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, UpdateSymlinkCallback) {
    MockCallbacks callbacks;
 
    EXPECT_CALL(callbacks, UpdateSymlinkCallback(link1)).Times(1);
    EXPECT_CALL(callbacks, UpdateSymlinkCallback(link2)).Times(1);
 
    auto cb = [&callbacks](const DataPointPath& path) { callbacks.UpdateSymlinkCallback(path); };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req;
    req.CreateSymlink(path1, "/link1"_dppath);
    req.CreateSymlink(path2, "/link2"_dppath);
    // The update swaps the targets of the two links.
    req.UpdateSymlink(path2, "/link1"_dppath, cb);
    req.UpdateSymlink(path1, "/link2"_dppath, cb);
    repo->SendRequest(req).Wait();
}
 
TEST_F(Callbacks, CreateDataPointCallbackMustBeReentrant) {
    // Send a second CreateDataPoint request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, CreateCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, CreateCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.CreateCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.CreateCallback(path);
        int value2 = 2;
        RepositoryIf::BatchRequest req2;
        req2.CreateDataPoint(path2, value2, std::nullopt, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    int value1 = 1;
    RepositoryIf::BatchRequest req1;
    req1.CreateDataPoint(path1, value1, std::nullopt, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, DeleteDataPointCallbackMustBeReentrant) {
    // Send a second DeleteDataPoint request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, DeleteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, DeleteCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.DeleteCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.DeleteCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.DeleteDataPoint(path2, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.DeleteDataPoint(path1, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, DataPointExistsCallbackMustBeReentrant) {
    // Send a second DataPointExists request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    bool result1, result2;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, ExistsCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ExistsCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.ExistsCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.ExistsCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.DataPointExists(path2, result2, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.DataPointExists(path1, result1, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, GetChildrenCallbackMustBeReentrant) {
    // Send a second GetChildren request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    using PathList = RepositoryIf::PathList;
    std::pair<PathList, PathList> result1, result2;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, GetChildrenCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, GetChildrenCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.GetChildrenCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.GetChildrenCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.GetChildren(path2, result2, false, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.GetChildren(path1, result1, true, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, WriteDataPointCallbackMustBeReentrant) {
    // Send a second WriteDataPoint request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RtcInt64 buffer1 = 1;
    RtcInt64 buffer2 = 2;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, WriteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, WriteCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.WriteCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.WriteCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.WriteDataPoint(path2, buffer2, std::nullopt, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.WriteDataPoint(path1, buffer1, std::nullopt, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, ReadDataPointCallbackMustBeReentrant) {
    // Send a second ReadDataPoint request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RtcInt64 result1, result2;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, ReadCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ReadCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.ReadCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.ReadCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.ReadDataPoint(path2, result2, std::nullopt, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.ReadDataPoint(path1, result1, std::nullopt, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, PartialWriteDataPointCallbackMustBeReentrant) {
    // Send a second PartialWriteDataPoint request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RtcVectorInt64 buffer1{1, 2};
    RtcVectorInt64 buffer2{3, 4};
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, WriteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, WriteCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.WriteCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.WriteCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.PartialWriteDataPoint(path2, buffer2, 0, 2, 0, std::nullopt, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints(RtcVectorInt64{0, 0});
 
    RepositoryIf::BatchRequest req1;
    req1.PartialWriteDataPoint(path1, buffer1, 0, 2, 0, std::nullopt, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, PartialReadDataPointCallbackMustBeReentrant) {
    // Send a second PartialReadDataPoint request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RtcVectorInt64 result1{0, 0};
    RtcVectorInt64 result2{0, 0};
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, ReadCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ReadCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.ReadCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.ReadCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.PartialReadDataPoint(path2, result2, 0, 2, 0, std::nullopt, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints(RtcVectorInt64{1, 2});
 
    RepositoryIf::BatchRequest req1;
    req1.PartialReadDataPoint(path1, result1, 0, 2, 0, std::nullopt, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, WriteMetaDataCallbackMustBeReentrant) {
    // Send a second WriteMetaData request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RepositoryIf::MetaData metadata1, metadata2;
    metadata1["comment"] = std::string{"foo"};
    metadata2["comment"] = std::string{"bar"};
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, WriteCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, WriteCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.WriteCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.WriteCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.WriteMetaData(path2, metadata2, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.WriteMetaData(path1, metadata1, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, ReadMetaDataCallbackMustBeReentrant) {
    // Send a second ReadMetaData request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RepositoryIf::MetaData result1, result2;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, ReadCallback(path1)).Times(1);
    EXPECT_CALL(callbacks, ReadCallback(path2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.ReadCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.ReadCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.ReadMetaData(path2, result2, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.ReadMetaData(path1, result1, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, CreateSymlinkCallbackMustBeReentrant) {
    // Send a second CreateSymlink request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, CreateSymlinkCallback(link1)).Times(1);
    EXPECT_CALL(callbacks, CreateSymlinkCallback(link2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.CreateSymlinkCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.CreateSymlinkCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.CreateSymlink(path2, "/link2"_dppath, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
 
    RepositoryIf::BatchRequest req1;
    req1.CreateSymlink(path1, "/link1"_dppath, cb1);
    repo->SendRequest(req1).Wait();
}
 
TEST_F(Callbacks, UpdateSymlinkCallbackMustBeReentrant) {
    // Send a second UpdateSymlink request within the callback and make sure it completes,
    // i.e it does not deadlock.
    MockCallbacks callbacks;
    RepositoryIf::MetaData result1, result2;
 
    // Since the second request is executed within the callback cb1, the order of the callbacks is
    // defined by the following sequence.
    testing::InSequence seq;
    EXPECT_CALL(callbacks, UpdateSymlinkCallback(link1)).Times(1);
    EXPECT_CALL(callbacks, UpdateSymlinkCallback(link2)).Times(1);
 
    auto cb2 = [&callbacks](const DataPointPath& path) { callbacks.UpdateSymlinkCallback(path); };
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.UpdateSymlinkCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.UpdateSymlink(path2, "/link2"_dppath, cb2);
        repo->SendRequest(req2).Wait();
    };
 
    SetupDataPoints();
    RepositoryIf::BatchRequest req0;
    req0.CreateSymlink(path1, "/link1"_dppath);
    req0.CreateSymlink(path2, "/link2"_dppath);
    repo->SendRequest(req0).Wait();
 
    RepositoryIf::BatchRequest req1;
    // The updates will swap the targets of the two links.
    req1.UpdateSymlink(path1, "/link1"_dppath, cb1);
    repo->SendRequest(req1).Wait();
}

 
class GetChildren : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        repo->CreateDataPoint("/topdir/datapoint1"_dppath, 0);
        repo->CreateDataPoint("/topdir/subdir1/datapoint2"_dppath, 0);
        repo->CreateDataPoint("/topdir/subdir1/datapoint3"_dppath, 0);
        repo->CreateDataPoint("/topdir/subdir2/datapoint4"_dppath, 0);
        repo->CreateDataPoint("/topdir/subdir21/datapoint5"_dppath, 0);
    }
 
    void TearDown() override {
        if (repo->DataPointExists("/topdir/datapoint1"_dppath)) {
            repo->DeleteDataPoint("/topdir/datapoint1"_dppath);
        }
        if (repo->DataPointExists("/topdir/subdir1/datapoint2"_dppath)) {
            repo->DeleteDataPoint("/topdir/subdir1/datapoint2"_dppath);
        }
        if (repo->DataPointExists("/topdir/subdir1/datapoint2"_dppath)) {
            repo->DeleteDataPoint("/topdir/subdir1/datapoint2"_dppath);
        }
        if (repo->DataPointExists("/topdir/subdir1/datapoint3"_dppath)) {
            repo->DeleteDataPoint("/topdir/subdir1/datapoint3"_dppath);
        }
        if (repo->DataPointExists("/topdir/subdir2/datapoint4"_dppath)) {
            repo->DeleteDataPoint("/topdir/subdir2/datapoint4"_dppath);
        }
        if (repo->DataPointExists("/topdir/subdir21/datapoint5"_dppath)) {
            repo->DeleteDataPoint("/topdir/subdir21/datapoint5"_dppath);
        }
    }
 
protected:
    std::shared_ptr<RepositoryIf> repo;
};
 
TEST_F(GetChildren, FromRootDir) {
    auto [dps, paths] = repo->GetChildren("/"_dppath);
    EXPECT_THAT(dps, IsEmpty());
    EXPECT_THAT(paths, UnorderedElementsAreArray({"/topdir"_dppath}));
}
 
TEST_F(GetChildren, FromTopDir) {
    auto [dps, paths] = repo->GetChildren("/topdir"_dppath);
    EXPECT_THAT(dps, UnorderedElementsAreArray({"/topdir/datapoint1"_dppath}));
    EXPECT_THAT(
        paths,
        UnorderedElementsAreArray(
            {"/topdir/subdir1"_dppath, "/topdir/subdir2"_dppath, "/topdir/subdir21"_dppath}));
}
 
TEST_F(GetChildren, FromSubDir1) {
    auto [dps, paths] = repo->GetChildren("/topdir/subdir1"_dppath);
    EXPECT_THAT(dps,
                UnorderedElementsAreArray(
                    {"/topdir/subdir1/datapoint2"_dppath, "/topdir/subdir1/datapoint3"_dppath}));
    EXPECT_THAT(paths, IsEmpty());
}
 
TEST_F(GetChildren, FromSubDir2) {
    auto [dps, paths] = repo->GetChildren("/topdir/subdir2"_dppath);
    EXPECT_THAT(dps, UnorderedElementsAreArray({"/topdir/subdir2/datapoint4"_dppath}));
    EXPECT_THAT(paths, IsEmpty());
}
 
TEST_F(GetChildren, NoChildrenForExistingDataPoint) {
    auto [dps, paths] = repo->GetChildren("/topdir/datapoint1"_dppath);
    EXPECT_THAT(dps, IsEmpty());
    EXPECT_THAT(paths, IsEmpty());
}
 
TEST_F(GetChildren, NoChildrenForNonExistingDataPoint) {
    auto [dps, paths] = repo->GetChildren("/does/not/exist"_dppath);
    EXPECT_THAT(dps, IsEmpty());
    EXPECT_THAT(paths, IsEmpty());
}
 
TEST_F(GetChildren, RecursiveFromRootDir) {
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
    EXPECT_THAT(dps,
                UnorderedElementsAreArray({"/topdir/datapoint1"_dppath,
                                           "/topdir/subdir1/datapoint2"_dppath,
                                           "/topdir/subdir1/datapoint3"_dppath,
                                           "/topdir/subdir2/datapoint4"_dppath,
                                           "/topdir/subdir21/datapoint5"_dppath}));
    EXPECT_THAT(paths,
                UnorderedElementsAreArray({"/topdir"_dppath,
                                           "/topdir/subdir1"_dppath,
                                           "/topdir/subdir2"_dppath,
                                           "/topdir/subdir21"_dppath}));
}
 
TEST_F(GetChildren, DeleteRecursiveFromRootDir) {
    repo->DeleteDataPoint("/"_dppath, true);
 
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
    EXPECT_THAT(dps, IsEmpty());
    EXPECT_THAT(paths, IsEmpty());
}
 
TEST_F(GetChildren, DeleteRecursiveFromTopDir) {
    repo->DeleteDataPoint("/topdir"_dppath, true);
 
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
    EXPECT_THAT(dps, IsEmpty());
    EXPECT_THAT(paths, IsEmpty());
}
 
TEST_F(GetChildren, DeleteRecursiveFromSubDir2) {
    repo->DeleteDataPoint("/topdir/subdir2"_dppath, true);
 
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
    EXPECT_THAT(dps,
                UnorderedElementsAreArray({"/topdir/datapoint1"_dppath,
                                           "/topdir/subdir1/datapoint2"_dppath,
                                           "/topdir/subdir1/datapoint3"_dppath,
                                           "/topdir/subdir21/datapoint5"_dppath}));
    EXPECT_THAT(paths,
                UnorderedElementsAreArray(
                    {"/topdir"_dppath, "/topdir/subdir1"_dppath, "/topdir/subdir21"_dppath}));
}

 
class Metadata : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        path = "/foo"_dppath;
    }
 
    void TearDown() override {
        if (repo->DataPointExists(path)) {
            repo->DeleteDataPoint(path);
        }
    }
 
protected:
    std::shared_ptr<RepositoryIf> repo;
    DataPointPath path;
};
 
TEST_F(Metadata, CreateDataPointWithMetadata) {
    auto t_start = RepositoryIf::Timestamp{};
    int initial_value = 0;
 
    RepositoryIf::MetaData md;
    md["timestamp"] = t_start;
    md["comment"] = std::string{"some comment"};
    md["units"] = std::string{"bar"};
 
    RepositoryIf::MetaData md_read;
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, initial_value, md);
    req.ReadMetaData(path, md_read);
    repo->SendRequest(req).Wait();
 
    ASSERT_TRUE(md_read.Contains("type"));
    ASSERT_TRUE(md_read.Contains("shape"));
    ASSERT_TRUE(md_read.Contains("timestamp"));
    ASSERT_TRUE(md_read.Contains("comment"));
    ASSERT_TRUE(md_read.Contains("units"));
 
    EXPECT_TRUE(md_read["type"].Cast<const std::type_info&>() == typeid(int));
    EXPECT_EQ(md_read["shape"].Cast<RtcVectorUInt64>(), RtcVectorUInt64{});
    EXPECT_EQ(md_read["timestamp"].Cast<RepositoryIf::Timestamp>(), t_start);
    EXPECT_EQ(md_read["comment"].Cast<std::string>(), std::string{"some comment"});
    EXPECT_EQ(md_read["units"].Cast<std::string>(), std::string{"bar"});
}
 
TEST_F(Metadata, WriteDataPointWithMetadata) {
    auto t_start = RepositoryIf::Timestamp{};
    int initial_value = 0;
 
    RepositoryIf::MetaData md;
    md["timestamp"] = t_start;
    md["comment"] = std::string{"some comment"};
    md["units"] = std::string{"bar"};
 
    RepositoryIf::MetaData md_read;
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, initial_value);
    req.WriteDataPoint(path, initial_value, md);
    req.ReadMetaData(path, md_read);
    repo->SendRequest(req).Wait();
 
    ASSERT_TRUE(md_read.Contains("timestamp"));
    ASSERT_TRUE(md_read.Contains("comment"));
    ASSERT_TRUE(md_read.Contains("units"));
 
    EXPECT_EQ(md_read["timestamp"].Cast<RepositoryIf::Timestamp>(), t_start);
    EXPECT_EQ(md_read["comment"].Cast<std::string>(), std::string{"some comment"});
    EXPECT_EQ(md_read["units"].Cast<std::string>(), std::string{"bar"});
}
 
TEST_F(Metadata, ReadDataPointWithMetadata) {
    auto t_start = RepositoryIf::Timestamp{};
    int initial_value = 0;
    int read_value = 1;
 
    RepositoryIf::MetaData md;
    md["timestamp"] = t_start;
    md["comment"] = std::string{"some comment"};
    md["units"] = std::string{"bar"};
 
    RepositoryIf::MetaData md_read;
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, initial_value, md);
    req.ReadDataPoint(path, read_value, md_read);
    repo->SendRequest(req).Wait();
 
    ASSERT_TRUE(md_read.Contains("type"));
    ASSERT_TRUE(md_read.Contains("shape"));
    ASSERT_TRUE(md_read.Contains("timestamp"));
    ASSERT_TRUE(md_read.Contains("comment"));
    ASSERT_TRUE(md_read.Contains("units"));
 
    EXPECT_EQ(md_read["timestamp"].Cast<RepositoryIf::Timestamp>(), t_start);
    EXPECT_EQ(md_read["comment"].Cast<std::string>(), std::string{"some comment"});
    EXPECT_EQ(md_read["units"].Cast<std::string>(), std::string{"bar"});
    EXPECT_TRUE(md_read["type"].Cast<const std::type_info&>() == typeid(int));
    EXPECT_EQ(md_read["shape"].Cast<RtcVectorUInt64>(), RtcVectorUInt64{});
}
 
TEST_F(Metadata, WriteMetadataOnly) {
    int initial_value = 0;
 
    RepositoryIf::MetaData md;
    md["comment"] = std::string{"some comment"};
    md["units"] = std::string{"bar"};
 
    RepositoryIf::MetaData md_read;
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, initial_value);
    req.WriteMetaData(path, md);
    req.ReadMetaData(path, md_read);
    repo->SendRequest(req).Wait();
 
    ASSERT_TRUE(md_read.Contains("comment"));
    ASSERT_TRUE(md_read.Contains("units"));
 
    EXPECT_EQ(md_read["comment"].Cast<std::string>(), std::string{"some comment"});
    EXPECT_EQ(md_read["units"].Cast<std::string>(), std::string{"bar"});
}
 
TEST_F(Metadata, UserMetadata) {
    {
        int int_create = 0;
        RepositoryIf::MetaData metadata;
        metadata["min"] = static_cast<int>(-3);
        metadata["max"] = static_cast<int>(3);
        metadata["text"] = std::string{"This is a custom text description."};
        RepositoryIf::MetaData metadata_read;
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, int_create, metadata);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
        ASSERT_TRUE(metadata_read.Contains("min"));
        ASSERT_TRUE(metadata_read.Contains("max"));
        EXPECT_EQ(metadata_read["min"].Cast<int>(), -3);
        EXPECT_EQ(metadata_read["max"].Cast<int>(), 3);
        EXPECT_EQ(metadata_read["text"].Cast<std::string>(), metadata["text"].Cast<std::string>());
    }
 
    {
        RepositoryIf::MetaData metadata;
        metadata["min"] = static_cast<int>(-5);
        metadata["max"] = static_cast<int>(5);
        metadata["text"] = std::string{"This is another description."};
        metadata["new_field"] = std::string{"A new field added."};
        RepositoryIf::MetaData metadata_read;
        RepositoryIf::BatchRequest req;
        req.WriteMetaData(path, metadata);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
        ASSERT_TRUE(metadata_read.Contains("min"));
        ASSERT_TRUE(metadata_read.Contains("max"));
        EXPECT_EQ(metadata_read["min"].Cast<int>(), -5);
        EXPECT_EQ(metadata_read["max"].Cast<int>(), 5);
        EXPECT_EQ(metadata_read["text"].Cast<std::string>(), metadata["text"].Cast<std::string>());
    }
 
    {
        int int_write = 3;
        RepositoryIf::MetaData metadata;
        metadata["min"] = static_cast<int>(-7);
        metadata["max"] = static_cast<int>(7);
        metadata["text"] = std::string{"This is a description."};
        metadata.Remove("new_field");
        RepositoryIf::MetaData metadata_read;
        RepositoryIf::BatchRequest req;
        req.WriteDataPoint(path, int_write, metadata);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
        ASSERT_TRUE(metadata_read.Contains("min"));
        ASSERT_TRUE(metadata_read.Contains("max"));
        EXPECT_EQ(metadata_read["min"].Cast<int>(), -7);
        EXPECT_EQ(metadata_read["max"].Cast<int>(), 7);
        EXPECT_EQ(metadata_read["text"].Cast<std::string>(), metadata["text"].Cast<std::string>());
    }
 
    {
        int int_write = 3;
        int int_read = 0;
        RepositoryIf::MetaData metadata;
        metadata["min"] = static_cast<int>(-9);
        metadata["max"] = static_cast<int>(9);
        metadata["text"] = std::string{"A description.\nBut on two lines."};
        metadata["new_field"] = static_cast<int>(9);
        RepositoryIf::MetaData metadata_read;
        RepositoryIf::BatchRequest req;
        req.WriteDataPoint(path, int_write, metadata);
        req.ReadDataPoint(path, int_read, metadata_read);
        repo->SendRequest(req).Wait();
        ASSERT_TRUE(metadata_read.Contains("min"));
        ASSERT_TRUE(metadata_read.Contains("max"));
        EXPECT_EQ(metadata_read["min"].Cast<int>(), -9);
        EXPECT_EQ(metadata_read["max"].Cast<int>(), 9);
        EXPECT_EQ(metadata_read["text"].Cast<std::string>(), metadata["text"].Cast<std::string>());
    }
}

 
class Symlinks : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        target_path = "/foo"_dppath;
        target_path_2 = "/bar"_dppath;
    }
 
    void TearDown() override {
        if (repo->DataPointExists(target_path)) {
            repo->DeleteDataPoint(target_path);
        }
        if (repo->DataPointExists(target_path_2)) {
            repo->DeleteDataPoint(target_path_2);
        }
        if (repo->DataPointExists("/links/foo"_dppath)) {
            repo->DeleteDataPoint("/links/foo"_dppath);
        }
        if (repo->DataPointExists("/links/bar"_dppath)) {
            repo->DeleteDataPoint("/links/bar"_dppath);
        }
    }
 
protected:
    std::shared_ptr<RepositoryIf> repo;
    DataPointPath target_path;
    DataPointPath target_path_2;
};
 
TEST_F(Symlinks, BasicPattern) {
    int int_create = 0;
    int int_read = 0;
    int int_read_2 = 0;
    int int_write = 4;
    bool foo_exists = false;
    bool bar_exists = false;
    bool foo_exists_later = false;
    bool bar_exists_later = false;
 
    repo->CreateDataPoint(target_path, int_create);
 
    RepositoryIf::BatchRequest req;
    req.CreateSymlink(target_path, "/links/foo1"_dppath);
    req.CreateSymlink(target_path, "/links/bar"_dppath);
    req.DataPointExists("/links/foo1"_dppath, foo_exists);
    req.DataPointExists("/links/bar"_dppath, bar_exists);
    req.ReadDataPoint("/links/foo1"_dppath, int_read);
    req.WriteDataPoint("/links/bar"_dppath, int_write);
    req.ReadDataPoint("/links/foo1"_dppath, int_read_2);
    req.DeleteDataPoint("/links/foo1"_dppath);
    req.DeleteDataPoint("/links/bar"_dppath);
    req.DataPointExists("/links/foo1"_dppath, foo_exists_later);
    req.DataPointExists("/links/bar"_dppath, bar_exists_later);
    repo->SendRequest(req).Wait();
 
    EXPECT_TRUE(foo_exists);
    EXPECT_TRUE(bar_exists);
    EXPECT_EQ(int_read, 0);
    EXPECT_EQ(int_read_2, 4);
    EXPECT_FALSE(foo_exists_later);
    EXPECT_FALSE(bar_exists_later);
}
 
TEST_F(Symlinks, AdvancedPattern) {
    int int_create = 0;
    int int_read = 0;
    int int_read_2 = 0;
    int int_write = 4;
    RepositoryIf::MetaData md_dp;
    RepositoryIf::MetaData md_dp_later;
    RepositoryIf::MetaData md_link;
    bool exists = false;
    std::set<DataPointPath> links_2;
 
    RepositoryIf::BatchRequest req;
    repo->CreateDataPoint(target_path, int_create);
    req.CreateSymlink(target_path, "/links/foo"_dppath);
    req.CreateSymlink(target_path, "/links/bar"_dppath);
    req.ReadMetaData(target_path, md_dp);
    req.ReadMetaData("/links/foo"_dppath, md_link);
    req.ReadDataPoint("/links/foo"_dppath, int_read);
    req.WriteDataPoint("/links/bar"_dppath, int_write);
    req.ReadDataPoint("/links/foo"_dppath, int_read_2);
    req.DeleteDataPoint("/links/foo"_dppath);
    req.DeleteDataPoint("/links/bar"_dppath);
    req.ReadMetaData(target_path, md_dp_later);
    req.DataPointExists(target_path, exists);
    repo->SendRequest(req).Wait();
 
    EXPECT_FALSE(md_dp.Contains("symlink_target"));
    EXPECT_TRUE(md_link.Contains("symlink_target"));
    EXPECT_EQ(md_link["symlink_target"].Cast<DataPointPath>(), DataPointPath{"/foo"});
 
    EXPECT_EQ(int_read, 0);
    EXPECT_EQ(int_read_2, 4);
    EXPECT_TRUE(exists);
}
 
TEST_F(Symlinks, LinksCanBeDeletedLikeRegularDataPoints) {
    DataPointPath link_path = "/links/foo"_dppath;
    int int_create = 0;
    bool link_exists_1 = false;
    bool link_exists_2 = true;
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(target_path, int_create);
    req.CreateSymlink(target_path, link_path);
    req.DataPointExists(link_path, link_exists_1);
    req.DeleteDataPoint(link_path);
    req.DataPointExists(link_path, link_exists_2);
    repo->SendRequest(req).Wait();
 
    EXPECT_TRUE(link_exists_1);
    EXPECT_FALSE(link_exists_2);
}
 
TEST_F(Symlinks, DanglingLinksCanBeCreatedAndDeleted) {
    DataPointPath link_path = "/links/foo"_dppath;
    int int_read = 1;
    bool link_exists = false;
 
    {
        // start with dangling symlink
        RepositoryIf::BatchRequest req;
        req.CreateSymlink(target_path, link_path);
        req.DataPointExists(link_path, link_exists);
        repo->SendRequest(req).Wait();
 
        // the link still exists
        EXPECT_TRUE(link_exists);
 
        // but we are unable to access the underlying datapoint
        EXPECT_THROW(
            { repo->ReadDataPoint(link_path, int_read); }, RepositoryIf::DataPointDoesNotExist);
    }
 
    // delete it
    EXPECT_NO_THROW(repo->DeleteDataPoint(link_path));
}
 
TEST_F(Symlinks, DanglingLinksCanBeFixedByCreatingTarget) {
    DataPointPath link_path = "/links/foo"_dppath;
    int int_read = 1;
    bool link_exists = false;
 
    {
        // start with dangling symlink
        RepositoryIf::BatchRequest req;
        req.CreateSymlink(target_path, link_path);
        req.DataPointExists(link_path, link_exists);
        repo->SendRequest(req).Wait();
 
        // the link still exists
        EXPECT_TRUE(link_exists);
 
        // but we are unable to access the underlying datapoint
        EXPECT_THROW(
            { repo->ReadDataPoint(link_path, int_read); }, RepositoryIf::DataPointDoesNotExist);
    }
 
    // fix it by creating the target datapoint
    repo->CreateDataPoint(target_path, int_read);
 
    // reading should work now
    EXPECT_NO_THROW(repo->ReadDataPoint(link_path, int_read));
}
 
TEST_F(Symlinks, LinksCanBeUpdated) {
    DataPointPath link_path = "/links/foo"_dppath;
    DataPointPath dangling_target_path = "/dangling_target"_dppath;
    int int_read = 1;
    bool link_exists = false;
 
    {
        // start with dangling symlink
        RepositoryIf::BatchRequest req;
        req.CreateSymlink(target_path, link_path);
        req.DataPointExists(link_path, link_exists);
        repo->SendRequest(req).Wait();
    }
 
    {
        // point it to a different datapoint
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(target_path_2, int_read);
        req.UpdateSymlink(target_path_2, link_path);
        repo->SendRequest(req).Wait();
 
        // reading should work now
        EXPECT_NO_THROW(repo->ReadDataPoint(link_path, int_read));
    }
 
    {
        // make it dangle again
        RepositoryIf::BatchRequest req;
        req.UpdateSymlink(dangling_target_path, link_path);
        repo->SendRequest(req).Wait();
 
        // reading should no longer work
        EXPECT_THROW(
            { repo->ReadDataPoint(link_path, int_read); }, RepositoryIf::DataPointDoesNotExist);
    }
}
 
TEST_F(Symlinks, DanglingLinksStillExistAsDataPoints) {
    DataPointPath link_path = "/links/foo"_dppath;
    int int_create = 0;
    int int_read = 1;
    bool link_exists = false;
    RepositoryIf::MetaData md;
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(target_path, int_create);
    req.CreateSymlink(target_path, link_path);
    req.DeleteDataPoint(target_path);
    req.DataPointExists(link_path, link_exists);
    repo->SendRequest(req).Wait();
 
    // the link still exists
    EXPECT_TRUE(link_exists);
 
    // but we are unable to access the underlying datapoint
    EXPECT_THROW(
        { repo->ReadDataPoint(link_path, int_read); }, RepositoryIf::DataPointDoesNotExist);
}

 
class ExceptionInterface : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        path = "/foo"_dppath;
        link_path = "/links/foo"_dppath;
        link_path2 = "/links/bar"_dppath;
    }
 
    void TearDown() override {
        if (repo->DataPointExists(link_path)) {
            repo->DeleteDataPoint(link_path);
        }
        if (repo->DataPointExists(link_path2)) {
            repo->DeleteDataPoint(link_path2);
        }
        if (repo->DataPointExists(path)) {
            repo->DeleteDataPoint(path);
        }
    }
 
protected:
    std::shared_ptr<RepositoryIf> repo;
    DataPointPath path;
    DataPointPath link_path;
    DataPointPath link_path2;
};
 
// TODO: This test is no longer compilable. Decide what to do.
/*
TEST_F(ExceptionInterface, CreateDataPointThrowsForUnsupportedDataType) {
    struct UnsupportedDataType {};
    UnsupportedDataType value;
 
    ASSERT_FALSE(repo->DataPointExists(path));
 
    EXPECT_ANY_THROW({ repo->CreateDataPoint(path, value); });
}
*/
 
TEST_F(ExceptionInterface, MethodsThrowForNonAbsoluteDataPointPath) {
    auto invalid_path = "relative/dp/path"_dppath;
    auto value = 42;
 
    EXPECT_THROW({ repo->DataPointExists(invalid_path); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW({ repo->GetDataPointType(invalid_path); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW(
        { repo->GetDataPointShape(invalid_path); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW({ repo->GetDataPointSize(invalid_path); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW({ repo->GetChildren(invalid_path); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW(
        { repo->CreateDataPoint(invalid_path, value); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW(
        { repo->WriteDataPoint(invalid_path, value); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW(
        { repo->ReadDataPoint(invalid_path, value); }, RepositoryIf::DataPointPathNotAbsolute);
 
    EXPECT_THROW({ repo->DeleteDataPoint(invalid_path); }, RepositoryIf::DataPointPathNotAbsolute);
}
 
TEST_F(ExceptionInterface, CreateDataPointThrowsForExistingDataPoint) {
    auto create_value = 42;
 
    ASSERT_FALSE(repo->DataPointExists(path));
 
    repo->CreateDataPoint(path, create_value);
    ASSERT_TRUE(repo->DataPointExists(path));
 
    EXPECT_THROW(
        { repo->CreateDataPoint(path, create_value); }, RepositoryIf::DataPointAlreadyExists);
}
 
TEST_F(ExceptionInterface, DeleteDataPointThrowsForNonExistingDataPoint) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    EXPECT_THROW({ repo->DeleteDataPoint(path); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, WriteDataPointThrowsIfDataPointDoesNotExist) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    EXPECT_THROW({ repo->WriteDataPoint(path, 14); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, WriteDataPointThrowsForIncompatibleDataType) {
    RtcInt64 int_buffer = 14;
    repo->CreateDataPoint(path, int_buffer);
 
    RtcFloat float_buffer = 14.0;
    EXPECT_THROW({ repo->WriteDataPoint(path, float_buffer); }, RepositoryIf::IncompatibleType);
}
 
TEST_F(ExceptionInterface, WriteDataPointThrowsForIncompatibleShape) {
    RtcInt64 int_buffer = 14;
    repo->CreateDataPoint(path, int_buffer);
 
    RtcVectorInt64 vec_buffer = {15, 16};
    EXPECT_THROW({ repo->WriteDataPoint(path, vec_buffer); }, RepositoryIf::IncompatibleType);
 
    RtcMatrixInt64 mat_buffer = {2, 2, {1, 2, 3, 4}};
    EXPECT_THROW({ repo->WriteDataPoint(path, mat_buffer); }, RepositoryIf::IncompatibleType);
}
 
TEST_F(ExceptionInterface, ReadDataPointThrowsForIncompatibleDataType) {
    RtcInt64 int_buffer = 14;
    RepositoryIf::BatchRequest req;
    repo->CreateDataPoint(path, int_buffer);
 
    RtcFloat float_buffer;
    EXPECT_THROW({ repo->ReadDataPoint(path, float_buffer); }, RepositoryIf::IncompatibleType);
}
 
TEST_F(ExceptionInterface, ReadDataPointThrowsForIncompatibleShape) {
    RtcInt64 int_buffer = 14;
    repo->CreateDataPoint(path, int_buffer);
 
    RtcVectorInt64 vec_buffer;
    EXPECT_THROW({ repo->ReadDataPoint(path, vec_buffer); }, RepositoryIf::IncompatibleType);
 
    RtcMatrixInt64 mat_buffer;
    EXPECT_THROW({ repo->ReadDataPoint(path, mat_buffer); }, RepositoryIf::IncompatibleType);
}
 
TEST_F(ExceptionInterface, ReadDataPointThrowsForTooSmallBuffer) {
    RtcVectorInt64 write_buffer(10);
    repo->CreateDataPoint(path, write_buffer);
 
    gsl::span<RtcInt64> read_buffer(write_buffer);
    auto too_small_read_buffer = read_buffer.subspan(0, 5);
    EXPECT_THROW(
        { repo->ReadDataPoint(path, too_small_read_buffer); }, RepositoryIf::BufferTooSmall);
}
 
TEST_F(ExceptionInterface, PartialWriteDataPointThrowsForOutOfBoundsAccess) {
    RtcVectorInt64 write_buffer(10);
    repo->CreateDataPoint(path, write_buffer);
 
    RtcVectorInt64 vec_buffer = {1, 2, 3, 4};
    RepositoryIf::BatchRequest req;
    req.PartialWriteDataPoint(path, vec_buffer, 0, 4, 8);
    EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::AccessOutOfBounds);
}
 
TEST_F(ExceptionInterface, PartialReadDataPointThrowsForOutOfBoundsAccess) {
    RtcVectorInt64 write_buffer(10);
    RtcVectorInt64 read_buffer(50);
    repo->CreateDataPoint(path, write_buffer);
 
    RepositoryIf::BatchRequest req;
    req.PartialReadDataPoint(path, read_buffer, 0, 15, 0);
    EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::AccessOutOfBounds);
}
 
TEST_F(ExceptionInterface, SetDataPointThrowsForNonExistingDatapoint) {
    EXPECT_THROW({ repo->SetDataPoint(path, 42); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, GetDataPointThrowsForNonExistingDatapoint) {
    EXPECT_THROW({ repo->GetDataPoint<RtcInt64>(path); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, GetDataPointTypeThrowsForNonExistingDatapoint) {
    EXPECT_THROW({ repo->GetDataPointType(path); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, GetDataPointSizeThrowsForNonExistingDatapoint) {
    EXPECT_THROW({ repo->GetDataPointSize(path); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, GetDataPointShapeThrowsForNonExistingDatapoint) {
    EXPECT_THROW({ repo->GetDataPointShape(path); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, WriteMetaDataThrowsForNonExistingDatapoint) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    RepositoryIf::MetaData metadata;
    RepositoryIf::BatchRequest req;
    req.WriteMetaData(path, metadata);
    EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, ExceptionIsThrownDuringCreationWhenUnsupportedMetaDataTypeIsUsed) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    struct UnsupportedMetaDataType {};
 
    EXPECT_THROW(
        {
            UnsupportedMetaDataType new_value;
            RepositoryIf::MetaData metadata;
            metadata["min"] = std::make_any<UnsupportedMetaDataType>(new_value);
            int initial_value = 12;
            RepositoryIf::BatchRequest req;
            req.CreateDataPoint(path, initial_value, metadata);
            repo->SendRequest(req).Wait();
        },
        RepositoryIf::MetaData::UnsupportedType);
}
 
TEST_F(ExceptionInterface, ExceptionIsThrownDuringWritingWhenUnsupportedMetaDataTypeIsUsed) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    repo->CreateDataPoint(path, 12);
 
    struct UnsupportedMetaDataType {};
 
    EXPECT_THROW(
        {
            UnsupportedMetaDataType new_value;
            RepositoryIf::MetaData metadata;
            metadata["min"] = std::make_any<UnsupportedMetaDataType>(new_value);
            RepositoryIf::BatchRequest req;
            req.WriteMetaData(path, metadata);
            repo->SendRequest(req).Wait();
        },
        RepositoryIf::MetaData::UnsupportedType);
}
 
TEST_F(ExceptionInterface, ReadMetaDataThrowsForNonExistingDatapoint) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    RepositoryIf::MetaData metadata;
    RepositoryIf::BatchRequest req;
    req.ReadMetaData(path, metadata);
    EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::DataPointDoesNotExist);
}
 
// TODO we did not conclude our discussion regarding links to links, for now they are disallowed
TEST_F(ExceptionInterface, CreatingSymlinkToSymlinkThrows) {
    ASSERT_FALSE(repo->DataPointExists(path));
    repo->CreateDataPoint(path, 42);
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateSymlink(path, link_path);
        repo->SendRequest(req).Wait();
    }
 
    RepositoryIf::BatchRequest req;
    req.CreateSymlink(link_path, link_path2);
    EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::OperationNotAllowed);
}
 
TEST_F(ExceptionInterface, UpdateSymlinkThrowsForNonExistingSymlink) {
    ASSERT_FALSE(repo->DataPointExists(path));
    repo->CreateDataPoint(path, 42);
 
    RepositoryIf::BatchRequest req;
    req.UpdateSymlink(path, link_path);
    EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::DataPointDoesNotExist);
}
 
TEST_F(ExceptionInterface, UpdateSymlinkToSymlinkCycleThrows) {
    ASSERT_FALSE(repo->DataPointExists(path));
    repo->CreateDataPoint(path, 42);
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateSymlink(path, link_path);
        req.CreateSymlink(path, link_path2);
        repo->SendRequest(req).Wait();
    }
 
    {
        RepositoryIf::BatchRequest req;
        req.UpdateSymlink(link_path2, link_path);
        EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::OperationNotAllowed);
    }
}
 
TEST_F(ExceptionInterface, WritingToDanglingSymlinkThrows) {
    {
        int initial_value = 0;
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, initial_value);
        req.CreateSymlink(path, link_path);
        req.DeleteDataPoint(path);
        repo->SendRequest(req).Wait();
    }
 
    {
        int write_value = 0;
        RepositoryIf::BatchRequest req;
        req.WriteDataPoint(link_path, write_value);
        EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::DataPointDoesNotExist);
    }
}
 
TEST_F(ExceptionInterface, ReadingFromDanglingSymlinkThrows) {
    int buffer = 0;
 
    {
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, buffer);
        req.CreateSymlink(path, link_path);
        req.DeleteDataPoint(path);
        repo->SendRequest(req).Wait();
    }
 
    {
        RepositoryIf::BatchRequest req;
        req.ReadDataPoint(link_path, buffer);
        EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RepositoryIf::DataPointDoesNotExist);
    }
}
 
TEST_F(ExceptionInterface, MultipleRequestFail) {
    bool exists = false;
    RtcInt64 value = 42;
 
    RepositoryIf::BatchRequest req;
    req.DataPointExists(path, exists);
    req.WriteDataPoint(path, value);
    req.ReadDataPoint(path, value);
    req.DataPointExists(path, exists);
    try {
        repo->SendRequest(req).Wait();
        FAIL() << "Call did not throw";
    } catch (const RepositoryIf::MultipleRequestsFailed& ex) {
        const auto& info = ex.GetInfo();
        ASSERT_EQ(info.size(), 4);
 
        EXPECT_EQ(info[0].status, RepositoryIf::MultipleRequestsFailed::Status::Success);
        EXPECT_EQ(info[1].status, RepositoryIf::MultipleRequestsFailed::Status::Failed);
        EXPECT_EQ(info[2].status, RepositoryIf::MultipleRequestsFailed::Status::Failed);
        EXPECT_EQ(info[3].status, RepositoryIf::MultipleRequestsFailed::Status::Success);
 
        EXPECT_EQ(info[0].exception, nullptr);
        ASSERT_NE(info[1].exception, nullptr);
        ASSERT_NE(info[2].exception, nullptr);
        EXPECT_EQ(info[3].exception, nullptr);
 
        EXPECT_THROW(std::rethrow_exception(info[1].exception),
                     RepositoryIf::DataPointDoesNotExist);
        EXPECT_THROW(std::rethrow_exception(info[2].exception),
                     RepositoryIf::DataPointDoesNotExist);
 
        // std::cout << ex.what(); // just to show that what() is available as wel
 
    } catch (...) {
        FAIL() << "Incorrect exception type";
    }
}

 
class MassiveParallelAccess : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        for (unsigned i = 0; i < 500; i++) {
            std::string name = fmt::format("/test/datapoint_{:0>2}", i);
            dp_paths.emplace_back(name);
        }
    }
 
    void TearDown() override {
        for (const auto& path : dp_paths) {
            if (repo->DataPointExists(path)) {
                repo->DeleteDataPoint(path);
            }
        }
    }
 
protected:
    std::shared_ptr<RepositoryIf> repo;
    std::vector<DataPointPath> dp_paths;
};
 
TEST_F(MassiveParallelAccess, BasicCrudOperations) {
    // parallel creation
    {
        std::vector<std::future<void>> futures;
 
        futures.reserve(dp_paths.size());
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.emplace_back(std::async(std::launch::async, [this, idx = i] {
                repo->CreateDataPoint(dp_paths[idx], idx);
            }));
        }
 
        for (auto& f : futures) {
            ASSERT_NO_THROW({ f.get(); });
        }
    }
 
    // parallel exists
    {
        std::vector<std::future<bool>> futures;
 
        futures.reserve(dp_paths.size());
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.emplace_back(std::async(std::launch::async, [this, idx = i] {
                return repo->DataPointExists(dp_paths[idx]);
            }));
        }
 
        for (auto& f : futures) {
            bool result = false;
            ASSERT_NO_THROW({ result = f.get(); });
            ASSERT_TRUE(result);
        }
    }
 
    // parallel set
    {
        std::vector<std::future<void>> futures;
 
        futures.reserve(dp_paths.size());
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.emplace_back(std::async(std::launch::async, [this, idx = i] {
                repo->SetDataPoint<unsigned>(dp_paths[idx], idx + 1);
            }));
        }
 
        for (auto& f : futures) {
            ASSERT_NO_THROW({ f.get(); });
        }
    }
 
    // parallel get
    {
        std::vector<std::future<unsigned>> futures;
 
        futures.reserve(dp_paths.size());
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.emplace_back(std::async(std::launch::async, [this, idx = i] {
                return repo->GetDataPoint<unsigned>(dp_paths[idx]);
            }));
        }
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            unsigned result = 0;
            ASSERT_NO_THROW({ result = futures.at(i).get(); });
            EXPECT_EQ(result, i + 1);
        }
    }
 
    // parallel deletion
    {
        std::vector<std::future<void>> futures;
 
        futures.reserve(dp_paths.size());
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.emplace_back(std::async(
                std::launch::async, [this, idx = i] { repo->DeleteDataPoint(dp_paths[idx]); }));
        }
 
        for (auto& f : futures) {
            ASSERT_NO_THROW({ f.get(); });
        }
    }
 
    // parallel exists
    {
        std::vector<std::future<bool>> futures;
 
        futures.reserve(dp_paths.size());
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.emplace_back(std::async(std::launch::async, [this, idx = i] {
                return repo->DataPointExists(dp_paths[idx]);
            }));
        }
 
        for (auto& f : futures) {
            bool result = true;
            ASSERT_NO_THROW({ result = f.get(); });
            ASSERT_FALSE(result);
        }
    }
}
 
TEST_F(MassiveParallelAccess, ParallelReadFromSameDatapointWithSameValue) {
    auto path = dp_paths[0];
    unsigned create_value = 42;
    repo->CreateDataPoint(path, create_value);
 
    {
        std::vector<std::future<unsigned>> futures;
 
        futures.reserve(500);
        for (unsigned i = 0; i < 500; i++) {
            futures.emplace_back(
                std::async(std::launch::async, [&] { return repo->GetDataPoint<unsigned>(path); }));
        }
 
        for (auto& f : futures) {
            auto result = 0;
            ASSERT_NO_THROW({ result = f.get(); });
            EXPECT_EQ(result, create_value);
        }
    }
}
 
TEST_F(MassiveParallelAccess, ParallelWriteToSameDatapointWithSameValue) {
    auto path = dp_paths[0];
    unsigned create_value = 42;
    repo->CreateDataPoint(path, create_value);
 
    {
        std::vector<std::future<void>> futures;
 
        futures.reserve(500);
        for (unsigned i = 0; i < 500; i++) {
            futures.emplace_back(
                std::async(std::launch::async, [&] { repo->SetDataPoint<unsigned>(path, 43); }));
        }
 
        for (auto& f : futures) {
            ASSERT_NO_THROW({ f.get(); });
        }
    }
 
    unsigned result;
    RepositoryIf::MetaData md;
    RepositoryIf::BatchRequest req;
    req.ReadDataPoint(path, result, md);
    repo->SendRequest(req).Wait();
 
    EXPECT_EQ(result, 43);
    EXPECT_EQ(md["sequence_id"].Cast<RtcUInt64>(), 500);
}
 
TEST_F(MassiveParallelAccess, ParallelInterleavingWritesToSameDatapointWithSameValue) {
    auto path = dp_paths[0];
    unsigned create_value = 42;
    repo->CreateDataPoint(path, create_value);
 
    {
        std::vector<std::future<void>> futures;
 
        futures.reserve(50);
        for (unsigned i = 0; i < 50; i++) {
            futures.emplace_back(std::async(std::launch::async, [&] {
                unsigned buffer = 43;
                RepositoryIf::BatchRequest req;
                for (unsigned j = 0; j < 10; j++) {
                    req.WriteDataPoint(path, buffer);
                }
                repo->SendRequest(req).Wait();
            }));
        }
 
        for (auto& f : futures) {
            ASSERT_NO_THROW({ f.get(); });
        }
    }
 
    unsigned result;
    RepositoryIf::MetaData md;
    RepositoryIf::BatchRequest req;
    req.ReadDataPoint(path, result, md);
    repo->SendRequest(req).Wait();
 
    EXPECT_EQ(result, 43);
    EXPECT_EQ(md["sequence_id"].Cast<RtcUInt64>(), 500);
}
 
TEST_F(MassiveParallelAccess, ParallelInterleavingReadsFromSameDatapointWithSameValue) {
    auto path = dp_paths[0];
    unsigned create_value = 42;
    repo->CreateDataPoint(path, create_value);
 
    {
        std::vector<std::future<unsigned>> futures;
 
        futures.reserve(50);
        for (unsigned i = 0; i < 50; i++) {
            futures.emplace_back(std::async(std::launch::async, [&] {
                unsigned buffer = 0;
                RepositoryIf::BatchRequest req;
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                req.ReadDataPoint(path, buffer);
                repo->SendRequest(req).Wait();
                return buffer;
            }));
        }
 
        for (auto& f : futures) {
            unsigned result = 0;
            ASSERT_NO_THROW({ result = f.get(); });
            EXPECT_EQ(result, 42);
        }
    }
}

 
class CustomTypeHandling : public testing::Test {
public:
    void SetUp() override {
        repo = MakeRepository();
        for (unsigned i = 0; i < 500; i++) {
            std::string name = fmt::format("/test/datapoint_{:0>2}", i);
            dp_paths.emplace_back(name);
        }
    }
 
    void TearDown() override {
        for (const auto& path : dp_paths) {
            if (repo->DataPointExists(path)) {
                repo->DeleteDataPoint(path);
            }
        }
    }
 
protected:
    std::vector<DataPointPath> dp_paths;
    std::shared_ptr<RepositoryIf> repo;
};
 
TEST_F(CustomTypeHandling, ThrowInGetShape) {
    DataPointPath path = dp_paths.front();
    ASSERT_FALSE(repo->DataPointExists(path));
    EXPECT_THROW({ repo->CreateDataPoint<ThrowInGetShape>(path); }, std::runtime_error);
    DataPointPath second_path = dp_paths.front();
    ASSERT_FALSE(repo->DataPointExists(second_path));
    EXPECT_THROW({ repo->CreateDataPoint<ThrowInGetShape>(second_path); }, std::runtime_error);
}
 
TEST_F(CustomTypeHandling, ThrowInMakeSpan) {
    DataPointPath path = dp_paths.front();
    ASSERT_FALSE(repo->DataPointExists(path));
    EXPECT_THROW({ repo->CreateDataPoint<ThrowInMakeSpan>(path); }, std::runtime_error);
    DataPointPath second_path = dp_paths.back();
    ASSERT_FALSE(repo->DataPointExists(second_path));
    EXPECT_THROW({ repo->CreateDataPoint<ThrowInMakeSpan>(second_path); }, std::runtime_error);
}
 
TEST_F(CustomTypeHandling, ThrowInResizeBuffer) {
    DataPointPath path = dp_paths.front();
    ASSERT_FALSE(repo->DataPointExists(path));
    EXPECT_THROW(
        {
            repo->CreateDataPoint<ThrowInResizeBuffer>(path);
            repo->GetDataPoint<ThrowInResizeBuffer>(path);
        },
        std::runtime_error);
    DataPointPath second_path = dp_paths.back();
    ASSERT_FALSE(repo->DataPointExists(second_path));
    EXPECT_THROW(
        {
            repo->CreateDataPoint<ThrowInResizeBuffer>(second_path);
            repo->GetDataPoint<ThrowInResizeBuffer>(second_path);
        },
        std::runtime_error);
}
 
}  // namespace rtctk::componentFramework::test
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_REPOSITORYIFTESTSUITE_HPP