RegisterWizard_Test.cpp

Go to the documentation of this file.

#include <gtest/gtest.h>
#include <boost/shared_ptr.hpp>
#include "robot_instance/RegisterWizard.h"

class TestProperties : public RegisterProperties
{
public:
    TestProperties();
    virtual ~TestProperties() {};
};

TestProperties::TestProperties()
{
    REGISTER_CERTIFICATE_VALUE = 0x4000;
    REGISTER_CERTIFICATE_MASK  = 0xF000;

    isWritable = true;

    registerProperty["flag1"] = PropertyDef("flag1", "0=disable,1=enable", BitMinion::BIT_ZERO_INDEX,   BitMinion::ONE_BIT_MASK);
    registerProperty["flag2"] = PropertyDef("flag2", "0=engage,1=release", BitMinion::BIT_ONE_INDEX,    BitMinion::ONE_BIT_MASK);
    registerProperty["value"] = PropertyDef("value", "repeat count",       BitMinion::BIT_EIGHT_INDEX,  BitMinion::FOUR_BIT_MASK);

    for (PropertyDefMap::iterator it = registerProperty.begin(); it != registerProperty.end(); it++)
    {
        registerPropertyVector.push_back(&(it->second));
    }

    sort(registerPropertyVector.begin(), registerPropertyVector.end(), comparePropertyDefPointers());
}

class RegisterWizardTest : public ::testing::Test
{
protected:
    virtual void SetUp()
    {
        testProperties.reset(new TestProperties());
        registerWizard.reset(new RegisterWizard(testProperties));
    }

    virtual void TearDown()
    {
    }

    boost::shared_ptr<TestProperties> testProperties;
    boost::shared_ptr<RegisterWizard> registerWizard;
    BitWizard<uint16_t>               bw;
    std::string                       prop;
    BitMinion::BitIndexEnumType       bitIndex;
    uint16_t                          registerValue;
    uint16_t                          checkValue;
};

TEST(RegisterWizardTest_NoFixture, Constructors)
{
    boost::shared_ptr<TestProperties> testProperties;
    ASSERT_NO_THROW(RegisterWizard registerWizard(testProperties));
}

TEST_F(RegisterWizardTest, CheckAndMaskRegister)
{
    registerValue = 0;
    registerWizard->certifyRegister(registerValue);
    EXPECT_EQ(testProperties->REGISTER_CERTIFICATE_VALUE, registerValue);

    registerValue = 0xF000;
    registerWizard->certifyRegister(registerValue);
    EXPECT_EQ(testProperties->REGISTER_CERTIFICATE_VALUE, registerValue);

    registerValue = 0x00FF;
    registerWizard->certifyRegister(registerValue);
    EXPECT_EQ(testProperties->REGISTER_CERTIFICATE_VALUE | 0x00FF, registerValue);
}

TEST_F(RegisterWizardTest, IsRegisterValid)
{
    registerValue = 0;
    EXPECT_FALSE(registerWizard->isRegisterCertified(registerValue));

    registerValue = 0x1278;
    EXPECT_FALSE(registerWizard->isRegisterCertified(registerValue));

    registerValue = testProperties->REGISTER_CERTIFICATE_VALUE;
    EXPECT_TRUE(registerWizard->isRegisterCertified(registerValue));

    registerValue = 0x1278;
    registerWizard->certifyRegister(registerValue);
    EXPECT_TRUE(registerWizard->isRegisterCertified(registerValue));
}

TEST_F(RegisterWizardTest, GetSetFlag1)
{
    prop = std::string("flag1");
    bitIndex = BitMinion::BIT_ZERO_INDEX;

    registerValue = 0;
    checkValue = testProperties->REGISTER_CERTIFICATE_VALUE;

    registerWizard->setRegisterValue(true, prop, registerValue);
    bw.setBit(true, bitIndex, checkValue);
    EXPECT_EQ(checkValue, registerValue);
    EXPECT_EQ(0x1, registerWizard->getRegisterValue(prop, registerValue));

    registerWizard->setRegisterValue(false, prop, registerValue);
    EXPECT_EQ(testProperties->REGISTER_CERTIFICATE_VALUE, registerValue);
    EXPECT_EQ(0x0, registerWizard->getRegisterValue(prop, registerValue));
}

TEST_F(RegisterWizardTest, GetSetFlag2)
{
    prop     = std::string("flag2");
    bitIndex = BitMinion::BIT_ONE_INDEX;

    registerValue = 0;
    checkValue    = testProperties->REGISTER_CERTIFICATE_VALUE;

    registerWizard->setRegisterValue(true, prop, registerValue);
    bw.setBit(true, bitIndex, checkValue);
    EXPECT_EQ(checkValue, registerValue);
    EXPECT_EQ(0x1, registerWizard->getRegisterValue(prop, registerValue));

    registerWizard->setRegisterValue(false, prop, registerValue);
    EXPECT_EQ(testProperties->REGISTER_CERTIFICATE_VALUE, registerValue);
    EXPECT_EQ(0x0, registerWizard->getRegisterValue(prop, registerValue));
}

TEST_F(RegisterWizardTest, GetSetValue)
{
    prop     = std::string("value");
    bitIndex = BitMinion::BIT_EIGHT_INDEX;

    registerValue = 0;
    checkValue    = testProperties->REGISTER_CERTIFICATE_VALUE;

    uint16_t controlValue = 12;

    registerWizard->setRegisterValue(controlValue, prop, registerValue);
    bw.setBits(controlValue, bitIndex, BitMinion::FOUR_BIT_MASK, checkValue);
    EXPECT_EQ(checkValue, registerValue);
    EXPECT_EQ(controlValue, registerWizard->getRegisterValue(prop, registerValue));

    registerWizard->setRegisterValue(0x0, prop, registerValue);
    EXPECT_EQ(testProperties->REGISTER_CERTIFICATE_VALUE, registerValue);
    EXPECT_EQ(0x0, registerWizard->getRegisterValue(prop, registerValue));
}

TEST_F(RegisterWizardTest, GetSetInvalid)
{
    prop = std::string("INVALID");

    uint16_t temp = 0;

    EXPECT_THROW(registerWizard->setRegisterValue(true, prop, temp), std::out_of_range);
    EXPECT_THROW(registerWizard->getRegisterValue(prop, temp), std::out_of_range);
}

TEST_F(RegisterWizardTest, RegisterToString)
{
    registerValue = 0;
    EXPECT_EQ(std::string("Register is invalid."), registerWizard->registerToString(registerValue));

    registerValue = 0x4303;
    EXPECT_NE(std::string("Register is invalid."), registerWizard->registerToString(registerValue));
    std::cout << registerWizard->registerToString(registerValue) << std::endl;
}

TEST_F(RegisterWizardTest, ChangedRegisterProperties)
{
    uint16_t flag0 = 0;
    uint16_t flag1 = (1 << BitMinion::BIT_ZERO_INDEX);
    uint16_t flag2 = (1 << BitMinion::BIT_ONE_INDEX);
    uint16_t flag3 = flag1 | flag2;

    std::vector< std::string > changed;
    EXPECT_NO_THROW(changed = registerWizard->changedRegisterProperties(0, 0));

    changed = registerWizard->changedRegisterProperties(flag0, flag0);
    EXPECT_EQ(0, changed.size());

    changed = registerWizard->changedRegisterProperties(flag0, flag1);
    EXPECT_EQ(1, changed.size());
    EXPECT_STREQ("flag1", changed[0].c_str());

    changed = registerWizard->changedRegisterProperties(flag1, flag0);
    EXPECT_EQ(1, changed.size());
    EXPECT_STREQ("flag1", changed[0].c_str());

    changed = registerWizard->changedRegisterProperties(flag0, flag2);
    EXPECT_EQ(1, changed.size());
    EXPECT_STREQ("flag2", changed[0].c_str());

    changed = registerWizard->changedRegisterProperties(flag2, flag0);
    EXPECT_EQ(1, changed.size());
    EXPECT_STREQ("flag2", changed[0].c_str());

    changed = registerWizard->changedRegisterProperties(flag0, flag3);
    EXPECT_EQ(2, changed.size());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag1") != changed.end());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag2") != changed.end());

    changed = registerWizard->changedRegisterProperties(flag3, flag0);
    EXPECT_EQ(2, changed.size());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag1") != changed.end());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag2") != changed.end());
}

TEST_F(RegisterWizardTest, ChangedRegisterPropertiesMasked)
{
    uint16_t flag0 = 0;
    uint16_t flag1 = (1 << BitMinion::BIT_ZERO_INDEX);
    uint16_t flag2 = (1 << BitMinion::BIT_ONE_INDEX);
    uint16_t flag3 = flag1 | flag2;

    std::vector< std::string > changed;
    EXPECT_NO_THROW(changed = registerWizard->changedRegisterProperties(0, 0, 0));

    changed = registerWizard->changedRegisterProperties(flag0, flag0, flag0);
    EXPECT_EQ(0, changed.size());

    changed = registerWizard->changedRegisterProperties(flag0, flag0, flag1);
    EXPECT_EQ(0, changed.size());

    changed = registerWizard->changedRegisterProperties(flag0, flag1, flag1);
    EXPECT_EQ(1, changed.size());
    EXPECT_STREQ("flag1", changed[0].c_str());

    changed = registerWizard->changedRegisterProperties(flag0, flag1, flag2);
    EXPECT_EQ(0, changed.size());

    changed = registerWizard->changedRegisterProperties(flag0, flag1, flag3);
    EXPECT_EQ(1, changed.size());
    EXPECT_STREQ("flag1", changed[0].c_str());

    changed = registerWizard->changedRegisterProperties(flag0, flag3, flag1);
    EXPECT_EQ(1, changed.size());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag1") != changed.end());

    changed = registerWizard->changedRegisterProperties(flag0, flag3, flag3);
    EXPECT_EQ(2, changed.size());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag1") != changed.end());
    EXPECT_TRUE(std::find(changed.begin(), changed.end(), "flag2") != changed.end());
}

TEST_F(RegisterWizardTest, Has)
{
    EXPECT_TRUE(registerWizard->has("flag1"));
    EXPECT_TRUE(registerWizard->has("flag2"));
    EXPECT_TRUE(registerWizard->has("value"));
    EXPECT_FALSE(registerWizard->has("asdf"));
}

TEST_F(RegisterWizardTest, GetRegisterProperties)
{
    std::vector< std::string > properties = registerWizard->getRegisterProperties();

    EXPECT_EQ(3, properties.size());
    EXPECT_STREQ("flag1", properties[0].c_str());
    EXPECT_STREQ("flag2", properties[1].c_str());
    EXPECT_STREQ("value", properties[2].c_str());
}

TEST_F(RegisterWizardTest, IsWritable)
{
    EXPECT_TRUE(registerWizard->isWritable());
}

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