runtimeRepoTestSuite.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TEST_RUNTIMEREPOTESTSUITE_HPP
#define RTCTK_COMPONENTFRAMEWORK_TEST_RUNTIMEREPOTESTSUITE_HPP
 
#include <rtctk/componentFramework/test/repositoryIfTestSuite.hpp>
 
namespace rtctk::componentFramework::test {
 
TEST_F(Metadata, WriteDataPointReturnsOptionalMetadata) {
    auto t_start = RepositoryIf::Timestamp{};
    int initial_value = 0;
 
    RepositoryIf::MetaData md;
    md["timestamp"] = t_start;
 
    RepositoryIf::BatchRequest req;
    req.CreateDataPoint(path, initial_value);
    req.WriteDataPoint(path, initial_value, md);
    repo->SendRequest(req).Wait();
 
    ASSERT_TRUE(md.Contains("timestamp"));
    ASSERT_TRUE(md.Contains("sequence_id"));
 
    EXPECT_EQ(md["timestamp"].Cast<RepositoryIf::Timestamp>(), t_start);
    EXPECT_EQ(md["sequence_id"].Cast<RtcUInt64>(), 1);
}
 
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);
    }
 
    {
        RepositoryIf::MetaData metadata_write;
 
        int new_value = 6;
        RepositoryIf::BatchRequest req;
        req.WriteDataPoint(path, new_value, metadata_write);
        repo->SendRequest(req).Wait();
 
        ASSERT_TRUE(metadata_write.Contains("sequence_id"));
        EXPECT_EQ(metadata_write["sequence_id"].Cast<RtcUInt64>(), 2);
    }
}
 
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);
    }
}
 
}  // namespace rtctk::componentFramework::test
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_RUNTIMEREPOTESTSUITE_HPP