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 <type_traits>
 
#pragma GCC diagnostic push
// Do not generate compiler warnings for deprecated API methods invoked in unit tests.
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
namespace rtctk::componentFramework::test {
 
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.push_back(DataPointPath(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, 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));
}
 
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);
}
 
 
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};
        }
    }
};
 
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;
    TypeParam write_value;
    TypeParam read_value;
    TypeParam result_value;
 
    if constexpr (std::is_same_v<TypeParam, RtcString>) {
        create_value = "0123456789abcdef";
        write_value = "abcd";
        result_value = "abcd456789abcdef";
    } else if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
        // clang-format off
        create_value = {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}};
        write_value = {std::byte{12}, std::byte{13}, std::byte{14}, std::byte{15}};
        result_value = {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<TypeParam, RtcMatrixBool>) {
        // clang-format off
        create_value = {4, 4, {false, false, false, false,
                               false, false, false, false,
                               false, false, false, false,
                               false, false, false, false}};
        write_value = {1, 4, {true, true, true, true}};
        result_value = {4, 4, {true,  true,  true,  true,
                               false, false, false, false,
                               false, false, false, false,
                               false, false, false, false}};
        // clang-format on
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
        // clang-format off
        create_value = {4, 4, {"1",  "2",  "3",  "4",
                               "5",  "6",  "7",  "8",
                               "9",  "10", "11", "12",
                               "13", "14", "15", "16"}};
        write_value = {1, 4, {"12", "13", "14", "15"}};
        result_value = {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<TypeParam, RtcVectorBool>) {
        // clang-format off
        create_value = {false, false, false, false, false, false, false, false,
                        false, false, false, false, false, false, false, false};
        write_value = {true, true, true, true};
        result_value = {true, true, true, true,  false, false, false, false,
                        false, false, false, false, false, false, false, false};
        // clang-format on
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
        // clang-format off
        create_value = {"1", "2", "3", "4", "5", "6", "7", "8",
                        "9", "10", "11", "12", "13", "14", "15", "16"};
        write_value = {"12", "13", "14", "15"};
        result_value = {"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<TypeParam>) {
        // clang-format off
        create_value = {4, 4, {1,  2,  3,  4,
                               5,  6,  7,  8,
                               9,  10, 11, 12,
                               13, 14, 15, 16}};
        write_value = {1, 4, {12, 13, 14, 15}};
        result_value = {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<TypeParam>) {
        create_value = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        write_value = {12, 13, 14, 15};
        result_value = {12, 13, 14, 15, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
 
    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();
 
    ASSERT_EQ(read_value, result_value);
}
 
TYPED_TEST(AdvancedOperation, PartialReadPattern) {
    auto path = this->dp_paths[0];
    auto& repo = *this->repo;
 
    TypeParam create_value;
    TypeParam read_value;
    TypeParam result_value;
 
    if constexpr (std::is_same_v<TypeParam, RtcString>) {
        create_value = "0123456789abcdef";
        result_value = "0123";
        read_value.resize(result_value.size());
    } else if constexpr (std::is_same_v<TypeParam, RtcBinary>) {
        // clang-format off
        create_value = {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}};
        result_value = {std::byte{1}, std::byte{2}, std::byte{3}, std::byte{4}};
        read_value.resize(result_value.size());
        // clang-format on
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixBool>) {
        // clang-format off
        create_value = {4, 4, {true,  true,  false, false,
                               false, false, true,  false,
                               false, false, false, true,
                               false, false, false, false}};
        result_value = {1, 4, {true, true, false, false}};
        read_value.resize(result_value.GetNrows(), result_value.GetNcols());
        // clang-format on
    } else if constexpr (std::is_same_v<TypeParam, RtcMatrixString>) {
        // clang-format off
        create_value = {4, 4, {"1",  "2",  "3",  "4",
                               "5",  "6",  "7",  "8",
                               "9",  "10", "11", "12",
                               "13", "14", "15", "16"}};
        result_value = {1, 4, {"1", "2", "3", "4"}};
        read_value.resize(result_value.GetNrows(), result_value.GetNcols());
        // clang-format on
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorBool>) {
        // clang-format off
        create_value = {true, false, true, false, true, false, true, false,
                        true, false, true, false, true, false, true, false};
        result_value = {true, false, true, false};
        read_value.resize(result_value.size());
        // clang-format on
    } else if constexpr (std::is_same_v<TypeParam, RtcVectorString>) {
        create_value = {
            "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16"};
        result_value = {"1", "2", "3", "4"};
        read_value.resize(result_value.size());
    } else if constexpr (IS_MATRIX_BUFFER_TYPE<TypeParam>) {
        // clang-format off
        create_value = {4, 4, {1,  2,  3,  4,
                               5,  6,  7,  8,
                               9,  10, 11, 12,
                               13, 14, 15, 16}};
        result_value = {1, 4, {1, 2, 3, 4}};
        read_value.resize(result_value.GetNrows(), result_value.GetNcols());
        // clang-format on
    } else if constexpr (IS_VECTOR_TYPE<TypeParam>) {
        create_value = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        result_value = {1, 2, 3, 4};
        read_value.resize(result_value.size());
    } else {
        FAIL() << "Should never enter here. There is a bug in the test code.";
    }
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, create_value);
    req.PartialReadDataPoint(path, read_value, 0, 4, 0);
    repo.SendRequest(req).Wait();
 
    ASSERT_EQ(read_value, result_value);
}
 
template <typename T>
struct TypeMap {};
 
template <>
struct TypeMap<RtcString> {
    using BufferType = RtcString;
    using SpanType = gsl::span<char>;
};
 
template <typename T, typename A>
struct TypeMap<MatrixBuffer<T, A>> {
    using BufferType = MatrixBuffer<T, A>;
    using SpanType = MatrixSpan<T>;
};
 
template <typename T, typename A>
struct TypeMap<std::vector<T, A>> {
    using BufferType = std::vector<T, A>;
    using SpanType = gsl::span<T>;
};
 
template <typename A>
struct TypeMap<std::vector<bool, A>> {
    using BufferType = boost::container::vector<bool, A>;
    using SpanType = gsl::span<bool>;
};
 
template <typename A>
struct TypeMap<MatrixBuffer<bool, A>> {
    using BufferType = boost::container::vector<bool, A>;
    using SpanType = MatrixSpan<bool>;
};
 
TYPED_TEST(AdvancedOperation, SpanAccess) {
    auto path = this->dp_paths[0];
    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;
    SpanT create_span;
    SpanT write_span;
    SpanT read_span;
 
    if constexpr (std::is_same_v<TypeParam, RtcMatrixBool>) {
        create_span = SpanT(2, 2, create_value);
        write_span = SpanT(2, 2, write_value);
        read_span = SpanT(2, 2, read_value);
    } else {
        create_span = SpanT(create_value);
        write_span = SpanT(write_value);
        read_span = SpanT(read_value);
    }
 
    repo.CreateDataPoint(path, create_span);
    ASSERT_EQ(repo.GetDataPointType(path), typeid(TypeParam));
 
    repo.ReadDataPoint(path, read_span);
    ASSERT_EQ(create_span, read_span);
 
    repo.WriteDataPoint(path, write_span);
    repo.ReadDataPoint(path, read_span);
    ASSERT_EQ(write_span, read_span);
 
    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 path2 = this->dp_paths[1];
        std::string_view create_view = create_value;
        std::string_view write_view = write_value;
 
        repo.CreateDataPoint(path2, create_view);
        ASSERT_EQ(repo.GetDataPointType(path2), typeid(TypeParam));
 
        repo.ReadDataPoint(path2, read_value);
        ASSERT_EQ(create_view, read_value);
 
        repo.WriteDataPoint(path2, write_view);
        repo.ReadDataPoint(path2, read_value);
        ASSERT_EQ(write_view, read_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];
        ValueType write_array[4];
        ValueType read_array[4];
        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];
        ValueType write_array[2][2];
        ValueType read_array[2][2];
        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 = std::bind(&MockCallbacks::CreateCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::DeleteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ExistsCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::GetChildrenCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::WriteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ReadCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::PartialWriteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::PartialReadCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::WriteMetaDataCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ReadMetaDataCallback, &callbacks, std::placeholders::_1);
 
    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(path1)).Times(1);
    EXPECT_CALL(callbacks, CreateSymlinkCallback(path2)).Times(1);
 
    auto cb = std::bind(&MockCallbacks::CreateSymlinkCallback, &callbacks, std::placeholders::_1);
 
    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(path1)).Times(1);
    EXPECT_CALL(callbacks, UpdateSymlinkCallback(path2)).Times(1);
 
    auto cb = std::bind(&MockCallbacks::UpdateSymlinkCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::CreateCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::DeleteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ExistsCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::GetChildrenCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::WriteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ReadCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::WriteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ReadCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::WriteCallback, &callbacks, std::placeholders::_1);
 
    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 = std::bind(&MockCallbacks::ReadCallback, &callbacks, std::placeholders::_1);
 
    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(path1)).Times(1);
    EXPECT_CALL(callbacks, CreateSymlinkCallback(path2)).Times(1);
 
    auto cb2 = std::bind(&MockCallbacks::CreateSymlinkCallback, &callbacks, std::placeholders::_1);
 
    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(path1)).Times(1);
    EXPECT_CALL(callbacks, UpdateSymlinkCallback(path2)).Times(1);
 
    auto cb2 = std::bind(&MockCallbacks::UpdateSymlinkCallback, &callbacks, std::placeholders::_1);
 
    auto cb1 = [&](const DataPointPath& path) {
        callbacks.UpdateSymlinkCallback(path);
        RepositoryIf::BatchRequest req2;
        req2.UpdateSymlink(path2, "/link1"_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, "/link2"_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);
    ASSERT_TRUE(dps.empty());
    ASSERT_EQ(paths.size(), 1);
    ASSERT_EQ(paths[0], "/topdir"_dppath);
}
 
TEST_F(GetChildren, FromTopDir) {
    auto [dps, paths] = repo->GetChildren("/topdir"_dppath);
    ASSERT_EQ(paths.size(), RtcVectorString::size_type(3));
    std::sort(paths.begin(), paths.end());
    EXPECT_EQ(paths[0], "/topdir/subdir1"_dppath);
    EXPECT_EQ(paths[1], "/topdir/subdir2"_dppath);
    EXPECT_EQ(paths[2], "/topdir/subdir21"_dppath);
    ASSERT_EQ(dps.size(), RtcVectorString::size_type(1));
    EXPECT_EQ(dps[0], "/topdir/datapoint1"_dppath);
}
 
TEST_F(GetChildren, FromSubDir1) {
    auto [dps, paths] = repo->GetChildren("/topdir/subdir1"_dppath);
    ASSERT_TRUE(paths.empty());
    ASSERT_EQ(dps.size(), RtcVectorString::size_type(2));
    std::sort(dps.begin(), dps.end());
    EXPECT_EQ(dps[0], "/topdir/subdir1/datapoint2"_dppath);
    EXPECT_EQ(dps[1], "/topdir/subdir1/datapoint3"_dppath);
}
 
TEST_F(GetChildren, FromSubDir2) {
    auto [dps, paths] = repo->GetChildren("/topdir/subdir2"_dppath);
    ASSERT_TRUE(paths.empty());
    ASSERT_EQ(dps.size(), RtcVectorString::size_type(1));
    std::sort(dps.begin(), dps.end());
    EXPECT_EQ(dps[0], "/topdir/subdir2/datapoint4"_dppath);
}
 
TEST_F(GetChildren, NoChildrenForExistingDataPoint) {
    auto [dps, paths] = repo->GetChildren("/topdir/datapoint1"_dppath);
    ASSERT_TRUE(paths.empty());
    ASSERT_TRUE(dps.empty());
}
 
TEST_F(GetChildren, NoChildrenForNonExistingDataPoint) {
    auto [dps, paths] = repo->GetChildren("/does/not/exist"_dppath);
    ASSERT_TRUE(paths.empty());
    ASSERT_TRUE(dps.empty());
}
 
TEST_F(GetChildren, RecursiveFromRootDir) {
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
 
    std::sort(dps.begin(), dps.end());
    ASSERT_EQ(dps.size(), 5);
    EXPECT_EQ(dps[0], "/topdir/datapoint1"_dppath);
    EXPECT_EQ(dps[1], "/topdir/subdir1/datapoint2"_dppath);
    EXPECT_EQ(dps[2], "/topdir/subdir1/datapoint3"_dppath);
    EXPECT_EQ(dps[3], "/topdir/subdir2/datapoint4"_dppath);
    EXPECT_EQ(dps[4], "/topdir/subdir21/datapoint5"_dppath);
 
    std::sort(paths.begin(), paths.end());
    ASSERT_EQ(paths.size(), 4);
    EXPECT_EQ(paths[0], "/topdir"_dppath);
    EXPECT_EQ(paths[1], "/topdir/subdir1"_dppath);
    EXPECT_EQ(paths[2], "/topdir/subdir2"_dppath);
    EXPECT_EQ(paths[3], "/topdir/subdir21"_dppath);
}
 
TEST_F(GetChildren, DeleteRecursiveFromRootDir) {
    repo->DeleteDataPoint("/"_dppath, true);
 
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
    EXPECT_EQ(dps.size(), 0);
    EXPECT_EQ(paths.size(), 0);
}
 
TEST_F(GetChildren, DeleteRecursiveFromTopDir) {
    repo->DeleteDataPoint("/topdir"_dppath, true);
 
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
    EXPECT_EQ(dps.size(), 0);
    EXPECT_EQ(paths.size(), 0);
}
 
TEST_F(GetChildren, DeleteRecursiveFromSubDir2) {
    repo->DeleteDataPoint("/topdir/subdir2"_dppath, true);
 
    auto [dps, paths] = repo->GetChildren("/"_dppath, true);
 
    std::sort(dps.begin(), dps.end());
    ASSERT_EQ(dps.size(), 4);
    EXPECT_EQ(dps[0], "/topdir/datapoint1"_dppath);
    EXPECT_EQ(dps[1], "/topdir/subdir1/datapoint2"_dppath);
    EXPECT_EQ(dps[2], "/topdir/subdir1/datapoint3"_dppath);
    EXPECT_EQ(dps[3], "/topdir/subdir21/datapoint5"_dppath);
 
    std::sort(paths.begin(), paths.end());
    EXPECT_EQ(paths.size(), 3);
    EXPECT_EQ(paths[0], "/topdir"_dppath);
    EXPECT_EQ(paths[1], "/topdir/subdir1"_dppath);
    EXPECT_EQ(paths[2], "/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, TimestampIncrementsOnWrite) {
    {
        auto t_start = RepositoryIf::Timestamp{};
        RepositoryIf::MetaData metadata_read;
 
        int initial_value = 0;
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, initial_value);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
 
        ASSERT_TRUE(metadata_read.Contains("timestamp"));
        EXPECT_GT(metadata_read["timestamp"].Cast<RepositoryIf::Timestamp>(), t_start);
    }
 
    {
        auto t_start = RepositoryIf::Timestamp{};
        RepositoryIf::MetaData metadata_read;
 
        int new_value = 4;
        RepositoryIf::BatchRequest req;
        req.WriteDataPoint(path, new_value);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
 
        ASSERT_TRUE(metadata_read.Contains("timestamp"));
        EXPECT_GT(metadata_read["timestamp"].Cast<RepositoryIf::Timestamp>(), t_start);
    }
}
 
TEST_F(Metadata, SequenceIdIncrementsOnWrite) {
    {
        RepositoryIf::MetaData metadata_read;
 
        int initial_value = 0;
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint(path, initial_value);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
 
        ASSERT_TRUE(metadata_read.Contains("sequence_id"));
        EXPECT_EQ(metadata_read["sequence_id"].Cast<RtcUInt64>(), 0);
    }
 
    {
        RepositoryIf::MetaData metadata_read;
 
        int new_value = 4;
        RepositoryIf::BatchRequest req;
        req.WriteDataPoint(path, new_value);
        req.ReadMetaData(path, metadata_read);
        repo->SendRequest(req).Wait();
 
        ASSERT_TRUE(metadata_read.Contains("sequence_id"));
        EXPECT_EQ(metadata_read["sequence_id"].Cast<RtcUInt64>(), 1);
    }
}
 
TEST_F(Metadata, ReadWithSpecificSequenceId) {
    // First setup the datapoint and write to it two times, making sure the resultant sequence ID
    // is 2. Then make sure we can successfully read the datapoint and get the correct value.
    {
        int int_create = 3;
        int int_write1 = 4;
        int int_write2 = 5;
        RepositoryIf::MetaData metadata;
 
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint("/foo"_dppath, int_create);
        req.WriteDataPoint("/foo"_dppath, int_write1);
        req.WriteDataPoint("/foo"_dppath, int_write2);
        req.ReadMetaData("/foo"_dppath, metadata);
        repo->SendRequest(req).Wait();
 
        ASSERT_EQ(metadata["sequence_id"].Cast<RtcUInt64>(), 2);
    }
 
    {
        int int_read;
        RepositoryIf::MetaData metadata = {{"sequence_id", static_cast<RtcUInt64>(2)}};
        RepositoryIf::BatchRequest req;
        req.ReadDataPoint("/foo"_dppath, int_read, metadata);
        repo->SendRequest(req).Wait();
        EXPECT_EQ(int_read, 5);
    }
}
 
TEST_F(Metadata, ReadWithWrongSequenceId) {
    // First setup the datapoint and write to it two times, making sure the resultant sequence ID
    // is 2. Then make check that an exception is thrown if a ReadDataPoint request is made with
    // a different sequence ID.
    {
        int int_create = 3;
        int int_write1 = 4;
        int int_write2 = 5;
        RepositoryIf::MetaData metadata;
 
        RepositoryIf::BatchRequest req;
        req.CreateDataPoint("/foo"_dppath, int_create);
        req.WriteDataPoint("/foo"_dppath, int_write1);
        req.WriteDataPoint("/foo"_dppath, int_write2);
        req.ReadMetaData("/foo"_dppath, metadata);
        repo->SendRequest(req).Wait();
 
        ASSERT_EQ(metadata["sequence_id"].Cast<RtcUInt64>(), 2);
    }
 
    {
        int int_read;
        RepositoryIf::MetaData metadata = {{"sequence_id", static_cast<RtcUInt64>(342)}};
        RepositoryIf::BatchRequest req;
        req.ReadDataPoint("/foo"_dppath, int_read, metadata);
        EXPECT_THROW({ repo->SendRequest(req).Wait(); }, RtctkException);
    }
}
 
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."};
        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."};
        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."};
        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();
        path = "/foo"_dppath;
    }
 
    void TearDown() override {
        if (repo->DataPointExists(path)) {
            repo->DeleteDataPoint(path);
        }
        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 path;
};
 
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(path, int_create);
 
    RepositoryIf::BatchRequest req;
    req.CreateSymlink(path, "/links/foo1"_dppath);
    req.CreateSymlink(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 = 0;
    std::set<DataPointPath> links_2;
 
    RepositoryIf::BatchRequest req;
    repo->CreateDataPoint(path, int_create);
    req.CreateSymlink(path, "/links/foo"_dppath);
    req.CreateSymlink(path, "/links/bar"_dppath);
    req.ReadMetaData(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(path, md_dp_later);
    req.DataPointExists(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"});
 
    ASSERT_TRUE(md_dp.Contains("symlinks"));  // symlinks-key present if datapoint has symlinks
    EXPECT_EQ(md_dp["symlinks"].Cast<std::set<DataPointPath>>(),
              std::set<DataPointPath>({"/links/foo"_dppath, "/links/bar"_dppath}));
    EXPECT_FALSE(md_link.Contains("symlinks"));  // symlinks-key not present for symlinks
 
    EXPECT_EQ(int_read, 0);
    EXPECT_EQ(int_read_2, 4);
    EXPECT_FALSE(md_dp_later.Contains("symlinks"));  // symlinks-key no longer there
    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(path, int_create);
    req.CreateSymlink(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, 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(path, int_create);
    req.CreateSymlink(path, link_path);
    req.DeleteDataPoint(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, 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);
}
 
TEST_F(ExceptionInterface, CreateSymlinkThrowsForNonExistingDatapoint) {
    ASSERT_FALSE(repo->DataPointExists(path));
 
    RepositoryIf::BatchRequest req;
    req.CreateSymlink(path, link_path);
    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, UpdateSymlinkThrowsForNonExistingDataPoint) {
    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.UpdateSymlink("/bar"_dppath, 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) {
        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.push_back(DataPointPath(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;
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < dp_paths.size(); i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < 500; i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < 500; i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < 50; i++) {
            futures.push_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;
 
        for (unsigned i = 0; i < 50; i++) {
            futures.push_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);
        }
    }
}
 
}  // namespace rtctk::componentFramework::test
 
#pragma GCC diagnostic pop
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_REPOSITORYIFTESTSUITE_HPP