DataElement_Test.cpp

Go to the documentation of this file.

#include <iostream>
#include <gtest/gtest.h>
#include "robot_instance/DataElement.h"
#include "shared_memory_transport/smtcore_daemon.hpp"
#include "shared_memory_transport/smtclient.hpp"

using namespace std;

TEST(DataElementTest, Constructors)
{
    DataElement dataElement;
    ASSERT_EQ((uint32_t)0, dataElement.getValue<uint32_t>());
    ASSERT_EQ(DataElement::Read, dataElement.getReadWrite());

    DataElement dataElementFloatWrite("float", DataElement::Write);
    ASSERT_EQ((float)0, dataElementFloatWrite.getValue<float>());
    ASSERT_EQ(DataElement::Write, dataElementFloatWrite.getReadWrite());
}

TEST(DataElementTest, GetSetReadWrite)
{
    DataElement dataElement;

    dataElement.setReadWrite(DataElement::Write);
    EXPECT_EQ(DataElement::Write, dataElement.getReadWrite());

    dataElement.setReadWrite(DataElement::Read);
    EXPECT_EQ(DataElement::Read, dataElement.getReadWrite());
}

TEST(DataElementTest, GetSetValue)
{
    DataElement dataElement;

    dataElement.setValue<bool>(true);
    EXPECT_EQ(true, dataElement.getValue<bool>());

    dataElement.setValue<int32_t>(-1);
    EXPECT_EQ((int32_t) - 1, dataElement.getValue<int32_t>());

    dataElement.setValue<int16_t>(-1);
    EXPECT_EQ((int16_t) - 1, dataElement.getValue<int16_t>());

    dataElement.setValue<int16_t>((int16_t) - 65536);
    EXPECT_EQ((int16_t)0, dataElement.getValue<int16_t>());

    dataElement.setValue<uint32_t>(-1);
    EXPECT_EQ((uint32_t) - 1, dataElement.getValue<uint32_t>());

    dataElement.setValue<uint16_t>((uint16_t)65536);
    EXPECT_EQ((uint16_t)0, dataElement.getValue<uint16_t>());

    dataElement.setValue<float>(3.1415);
    EXPECT_EQ((float)3.1415, dataElement.getValue<float>());

    dataElement.setValue<float>(0);
    EXPECT_THROW(dataElement.getValue<uint32_t>(), invalid_argument);
}

// This test is awkward because gtest won't let me EXPECT_EQ two type_infos.
TEST(DataElementTest, GetType)
{
    DataElement dataElement;
    bool isCorrectType;

    if (typeid(uint32_t) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    dataElement.setValue<int32_t>(-2);

    if (typeid(int32_t) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    dataElement.setValue<bool>(true);

    if (typeid(bool) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    dataElement.setValue<float>(1.112);

    if (typeid(float) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);
}

TEST(DataElementTest, GetSize)
{
    DataElement dataElementBool  ("bool",     DataElement::Read);
    DataElement dataElementUInt16("uint16_t", DataElement::Read);
    DataElement dataElementInt16 ("int16_t",  DataElement::Read);
    DataElement dataElementUInt32("uint32_t", DataElement::Read);
    DataElement dataElementInt32 ("int32_t",  DataElement::Read);
    DataElement dataElementFloat ("float",    DataElement::Read);

    EXPECT_EQ(DataElement::EightBit,     dataElementBool.getSize());
    EXPECT_EQ(DataElement::SixteenBit,   dataElementUInt16.getSize());
    EXPECT_EQ(DataElement::SixteenBit,   dataElementInt16.getSize());
    EXPECT_EQ(DataElement::ThirtyTwoBit, dataElementUInt32.getSize());
    EXPECT_EQ(DataElement::ThirtyTwoBit, dataElementInt32.getSize());
    EXPECT_EQ(DataElement::ThirtyTwoBit, dataElementFloat.getSize());
}

TEST(DataElementTest, ToString)
{
    DataElement dataElement;
    std::string s;

    s.append("DataElement:\n");
    s.append("         Value: 0\n");
    s.append("          Type: j\n");
    s.append("          Size: 32\n");
    s.append("    Read/Write: Read");
    EXPECT_EQ(s, dataElement.toString());

    DataElement dataElement2("float", DataElement::Write);
    dataElement2.setValue<float>(-1.123);
    s.clear();
    s.append("DataElement:\n");
    s.append("         Value: -1.123\n");
    s.append("          Type: f\n");
    s.append("          Size: 32\n");
    s.append("    Read/Write: Write");
    EXPECT_EQ(s, dataElement2.toString());

    DataElement dataElement3("int16_t", DataElement::Write);
    dataElement3.setValue<int16_t>(-1);
    s.clear();
    s.append("DataElement:\n");
    s.append("         Value: -1\n");
    s.append("          Type: s\n");
    s.append("          Size: 16\n");
    s.append("    Read/Write: Write");
    EXPECT_EQ(s, dataElement3.toString());

    DataElement dataElement4("uint16_t", DataElement::Write);
    dataElement4.setValue<uint16_t>(2);
    s.clear();
    s.append("DataElement:\n");
    s.append("         Value: 2\n");
    s.append("          Type: t\n");
    s.append("          Size: 16\n");
    s.append("    Read/Write: Write");
    EXPECT_EQ(s, dataElement4.toString());

    DataElement dataElement5("bool", DataElement::Write);
    dataElement5.setValue<bool>(true);
    s.clear();
    s.append("DataElement:\n");
    s.append("         Value: 1\n");
    s.append("          Type: b\n");
    s.append("          Size: 8\n");
    s.append("    Read/Write: Write");
    EXPECT_EQ(s, dataElement5.toString());
}

class DataElementTestSMT : public ::testing::Test
{
protected:
    static void SetUpTestCase() {
        // start an smtcore with a random port so we don't collide with any service.
        smtcore.startSmtCore(true);
    }
    static void TearDownTestCase() {
        // Shut down the SMTcore instance we started.
        smtcore.shutdownSmtCore();
    }

    virtual void SetUp(){
        // Create an smtclient with the created smtcore port
        smtclient = new SMT::SMTClient("http://localhost:" + std::to_string(smtcore.getPort()) + "/");
    }

    virtual void TearDown(){
        // Cleanup smtclient
        delete smtclient;
        smtclient = nullptr;
    }
    
    SMT::SMTClient* smtclient;

    static SMTCoreDaemon smtcore;
};
// Because we actually need something for the static member to link to.
SMTCoreDaemon DataElementTestSMT::smtcore;

TEST_F(DataElementTestSMT, Constructors)
{
    auto resource = std::make_shared<SMT::Resource>( smtclient->createResource("ConstructorsTest", "uint32", 0, 0, "big", "") );
    DataElement dataElement("uint32_t", DataElement::Read, resource);
    ASSERT_EQ((uint32_t)0, dataElement.getValue<uint32_t>());
    ASSERT_EQ(DataElement::Read, dataElement.getReadWrite());
    EXPECT_NE(nullptr, dataElement.smtResource);
    smtclient->destroyResource("ConstructorsTest");

    resource = std::make_shared<SMT::Resource>( smtclient->createResource("ConstructorsTestFloat", "float32", 0, 0, "big", "") );
    DataElement dataElementFloatWrite("float", DataElement::Write, resource);
    ASSERT_EQ((float)0, dataElementFloatWrite.getValue<float>());
    ASSERT_EQ(DataElement::Write, dataElementFloatWrite.getReadWrite());
    EXPECT_NE(nullptr, dataElement.smtResource);
    smtclient->destroyResource("ConstructorsTestFloat");

    // Clean up after ourselves
    smtclient->deleteShmFile();
}

TEST_F(DataElementTestSMT, SetDEGetSMTValue)
{
    // Create an SMTResource & DataElement using that resource.
    auto resourceInt32 = std::make_shared<SMT::Resource>( smtclient->createResource("GetSetValueInt32", "int32", 0, 0, "big", "") );
    DataElement dataElementInt32("int32_t", DataElement::Write, resourceInt32);
    // Set a value through the DataElement
    dataElementInt32.setValue<int32_t>(-1);
    // Retrieve it from SMT
    EXPECT_EQ((int32_t) - 1, resourceInt32->get<int32_t>());
    dataElementInt32.setValue<int32_t>(12);
    EXPECT_EQ((int32_t) 12, resourceInt32->get<int32_t>());

    auto resourceInt16 = std::make_shared<SMT::Resource>( smtclient->createResource("GetSetValueInt16", "int16", 0, 0, "big", "") );
    DataElement dataElementInt16("int16_t", DataElement::Write, resourceInt16);
    dataElementInt16.setValue<int16_t>(-1);
    EXPECT_EQ((int16_t) - 1, resourceInt16->get<int16_t>());
    dataElementInt16.setValue<int16_t>(12);
    EXPECT_EQ((int16_t) 12, resourceInt16->get<int16_t>());

    auto resourceUInt32 = std::make_shared<SMT::Resource>( smtclient->createResource("GetSetValueUInt32", "uint32", 0, 0, "big", "") );
    DataElement dataElementUInt32("uint32_t", DataElement::Write, resourceUInt32);
    dataElementUInt32.setValue<uint32_t>(-1);
    EXPECT_EQ((uint32_t) - 1, resourceUInt32->get<uint32_t>());
    dataElementUInt32.setValue<uint32_t>(12);
    EXPECT_EQ((uint32_t) 12, resourceUInt32->get<uint32_t>());

    auto resourceUInt16 = std::make_shared<SMT::Resource>( smtclient->createResource("GetSetValueUInt16", "uint16", 0, 0, "big", "") );
    DataElement dataElementUInt16("uint16_t", DataElement::Write, resourceUInt16);
    dataElementUInt16.setValue<uint16_t>(-1);
    EXPECT_EQ((uint16_t) - 1, resourceUInt16->get<uint16_t>());
    dataElementUInt16.setValue<uint16_t>(12);
    EXPECT_EQ((uint16_t) 12, resourceUInt16->get<uint16_t>());

    auto resourceFloat32 = std::make_shared<SMT::Resource>( smtclient->createResource("GetSetValueFloat32", "float32", 0, 0, "big", "") );
    DataElement dataElementFloat32("float", DataElement::Write, resourceFloat32);
    dataElementFloat32.setValue<float>((float) 3.1415);
    EXPECT_FLOAT_EQ((float) 3.1415, resourceFloat32->get<float>());

    auto resourceBool = std::make_shared<SMT::Resource>( smtclient->createResource("GetSetValueBool", "uint8", 0, 0, "big", "") );
    DataElement dataElement("bool", DataElement::Write, resourceBool);
    dataElement.setValue<bool>(true);
    EXPECT_EQ(true, resourceBool->get<bool>());
    dataElement.setValue<bool>(false);
    EXPECT_EQ(false, resourceBool->get<bool>());

    // dataElement.setValue<float>(0);
    // EXPECT_THROW(dataElement.getValue<uint32_t>(), invalid_argument);
}

// This test is awkward because gtest won't let me EXPECT_EQ two type_infos.
TEST_F(DataElementTestSMT, GetType)
{
    auto resource = std::make_shared<SMT::Resource>( smtclient->createResource("GetTypeTest", "uint32", 0, 0, "big", "") );
    DataElement dataElement("uint32_t", DataElement::Write, resource);
    bool isCorrectType;

    if (typeid(uint32_t) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    dataElement.setValue<int32_t>(-2);

    if (typeid(int32_t) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    dataElement.setValue<bool>(true);

    if (typeid(bool) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    dataElement.setValue<float>(1.112);

    if (typeid(float) == *dataElement.getType())
    {
        isCorrectType = true;
    }
    else
    {
        isCorrectType = false;
    }

    EXPECT_TRUE(isCorrectType);

    smtclient->destroyResource("GetTypeTest");
    // Clean up after ourselves
    smtclient->deleteShmFile();
}


int main(int argc, char** argv)
{
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}