using std::string;
using std::vector;
- template<typename T>
- void parsedEqual(T expected, const std::string& actualStr)
+ void parsedEqual(double expected, const std::string& actualStr)
{
- T actual = boost::lexical_cast<T>(actualStr);
- EXPECT_LT(std::abs(expected - actual), std::numeric_limits<T>::epsilon());
+ double actual = boost::lexical_cast<double>(actualStr);
+ EXPECT_GE(actual, expected - .0000001);
+ EXPECT_LE(actual, expected + .0000001);
}
// getValueToString(all types)
EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
}
+ TEST(OCRepresentationValueToString, ByteString)
+ {
+ static const std::string AttrName = "ByteStringTest";
+ static uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
+ 0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
+
+ OCByteString bytestring {binval, sizeof(binval)};
+ OCRepresentation rep;
+
+ rep.setValue(AttrName, bytestring);
+ const char* expected = "\\x1\\x2\\x3\\x4\\x5\\x6\\x7\\x8"
+ "\\x9\\x0\\xa\\xb\\xc\\xd\\xe\\xf";
+ EXPECT_STREQ(expected, rep.getValueToString(AttrName).c_str() );
+ }
+
TEST(OCRepresentationValueToString, IntegerVector)
{
static const std::string AttrName = "VectorTest";
EXPECT_EQ(Expected, rep[AttrName].getValueToString());
}
+ TEST(OCRepresentationValueToByteString, ByteStringVector)
+ {
+ static const std::string AttrName = "VectorTest";
+ OCRepresentation rep;
+
+ uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
+ OCByteString s1 {binval1, sizeof(binval1)};
+ uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
+ OCByteString s2 {binval2, sizeof(binval2)};
+ uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
+ OCByteString s3 {binval3, sizeof(binval3)};
+ vector<OCByteString> vect {s1, s2, s3};
+
+ uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
+ OCByteString s4 {binval4, sizeof(binval4)};
+ uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
+ OCByteString s5 {binval5, sizeof(binval5)};
+ uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
+ OCByteString s6 {binval6, sizeof(binval6)};
+ vector<OCByteString> vect2 {s4, s5, s6};
+
+ rep.setValue(AttrName, vect);
+ const char *expected1tob = "[\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb ]";
+ EXPECT_EQ(expected1tob, rep.getValueToString(AttrName));
+ EXPECT_EQ(expected1tob, rep[AttrName].getValueToString());
+
+ rep.setValue(AttrName, vect2);
+ const char *expectedcto18 = "[\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 ]";
+ EXPECT_EQ(expectedcto18, rep.getValueToString(AttrName));
+ EXPECT_EQ(expectedcto18, rep[AttrName].getValueToString());
+ }
+
+ TEST(OCRepresentationValueToByteString, ByteStringVectorVector)
+ {
+ static const std::string AttrName = "VectorTest";
+ OCRepresentation rep;
+
+ uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
+ OCByteString s1 {binval1, sizeof(binval1)};
+ uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
+ OCByteString s2 {binval2, sizeof(binval2)};
+ uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
+ OCByteString s3 {binval3, sizeof(binval3)};
+ vector<OCByteString> vect1 {s1, s2, s3};
+
+ uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
+ OCByteString s4 {binval4, sizeof(binval4)};
+ uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
+ OCByteString s5 {binval5, sizeof(binval5)};
+ uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
+ OCByteString s6 {binval6, sizeof(binval6)};
+ vector<OCByteString> vect2 {s4, s5, s6};
+
+ vector<vector<OCByteString>> vect {vect1, vect2};
+
+ rep.setValue(AttrName, vect);
+
+ const char *expected =
+ "[["
+ "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
+ "] ["
+ "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
+ "] ]"
+ ;
+
+ EXPECT_EQ(expected, rep.getValueToString(AttrName));
+ EXPECT_EQ(expected, rep[AttrName].getValueToString());
+ }
+
+ TEST(OCRepresentationValueToByteString, ByteStringVectorVectorVector)
+ {
+ static const std::string AttrName = "VectorTest";
+ OCRepresentation rep;
+
+ uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
+ OCByteString s1 {binval1, sizeof(binval1)};
+ uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
+ OCByteString s2 {binval2, sizeof(binval2)};
+ uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
+ OCByteString s3 {binval3, sizeof(binval3)};
+ vector<OCByteString> vect11 {s1, s2, s3};
+
+ uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
+ OCByteString s4 {binval4, sizeof(binval4)};
+ uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
+ OCByteString s5 {binval5, sizeof(binval5)};
+ uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
+ OCByteString s6 {binval6, sizeof(binval6)};
+ vector<OCByteString> vect12 {s4, s5, s6};
+
+ uint8_t binval7[] = {0x19, 0x10, 0x1A, 0x1B};
+ OCByteString s7 {binval7, sizeof(binval7)};
+ uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
+ OCByteString s8 {binval8, sizeof(binval8)};
+ vector<OCByteString> vect21 {s7, s8};
+
+ uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
+ OCByteString s9 {binval9, sizeof(binval9)};
+ vector<OCByteString> vect22 {s9};
+
+ vector<vector<OCByteString>> vect1 {vect11, vect12};
+ vector<vector<OCByteString>> vect2 {vect21, vect22};
+ vector<vector<vector<OCByteString>>> vect {vect1, vect2};
+ rep.setValue(AttrName, vect);
+ static const std::string expected =
+ "[[["
+ "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
+ "] ["
+ "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
+ "] ] [["
+ "\\x19\\x10\\x1a\\x1b \\x1c\\x1d\\x1e\\x1f "
+ "] ["
+ "\\x21\\x22\\x23\\x24 "
+ "] ] ]";
+
+ EXPECT_EQ(expected, rep.getValueToString(AttrName));
+ EXPECT_EQ(expected, rep[AttrName].getValueToString());
+ }
+
TEST(OCRepresentationValueToString, SubRepresentationVector)
{
static const std::string AttrName = "VectorTest";
EXPECT_EQ(nullptr, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
int badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
- TEST(OCRepresentationSubscript, Boolean)
+ //Disabled this test due to older GCC v4.6 fails for this test.
+ //We will enable it when we have a fix for it.
+ TEST(OCRepresentationSubscript, DISABLED_Boolean)
{
static const std::string AttrName = "BooleanTest";
OCRepresentation rep;
EXPECT_EQ(repsource, repout);
int badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
(void)badout;
}
EXPECT_EQ(repsource.getUri(), repout2.getUri());
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
EXPECT_EQ(repsource, repout2);
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
vector<OCRepresentation> repout2;
repout2 = rep[AttrName];
- EXPECT_EQ(2, repout.size());
+ EXPECT_EQ(2u, repout.size());
EXPECT_EQ(inner1.getUri(), repout[0].getUri());
EXPECT_EQ(inner2.getUri(), repout[1].getUri());
- EXPECT_EQ(2, repout2.size());
+ EXPECT_EQ(2u, repout2.size());
EXPECT_EQ(inner1.getUri(), repout2[0].getUri());
EXPECT_EQ(inner2.getUri(), repout2[1].getUri());
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
vector<vector<OCRepresentation>> repout2;
repout2 = rep[AttrName];
- EXPECT_EQ(2, repout.size());
- EXPECT_EQ(2, repout[0].size());
+ EXPECT_EQ(2u, repout.size());
+ EXPECT_EQ(2u, repout[0].size());
EXPECT_EQ(inner1.getUri(), repout[0][0].getUri());
EXPECT_EQ(inner2.getUri(), repout[0][1].getUri());
- EXPECT_EQ(2, repout.size());
- EXPECT_EQ(2, repout[1].size());
+ EXPECT_EQ(2u, repout.size());
+ EXPECT_EQ(2u, repout[1].size());
EXPECT_EQ(inner3.getUri(), repout[1][0].getUri());
EXPECT_EQ(inner4.getUri(), repout[1][1].getUri());
- EXPECT_EQ(2, repout2.size());
- EXPECT_EQ(2, repout2[0].size());
+ EXPECT_EQ(2u, repout2.size());
+ EXPECT_EQ(2u, repout2[0].size());
EXPECT_EQ(inner1.getUri(), repout2[0][0].getUri());
EXPECT_EQ(inner2.getUri(), repout2[0][1].getUri());
- EXPECT_EQ(2, repout2.size());
- EXPECT_EQ(2, repout2[1].size());
+ EXPECT_EQ(2u, repout2.size());
+ EXPECT_EQ(2u, repout2[1].size());
EXPECT_EQ(inner3.getUri(), repout2[1][0].getUri());
EXPECT_EQ(inner4.getUri(), repout2[1][1].getUri());
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
vector<vector<vector<OCRepresentation>>> repout2;
repout2 = rep[AttrName];
- EXPECT_EQ(2, repout.size());
- EXPECT_EQ(2, repout[0].size());
- EXPECT_EQ(2, repout[0][0].size());
+ EXPECT_EQ(2u, repout.size());
+ EXPECT_EQ(2u, repout[0].size());
+ EXPECT_EQ(2u, repout[0][0].size());
EXPECT_EQ(inner1.getUri(), repout[0][0][0].getUri());
EXPECT_EQ(inner2.getUri(), repout[0][0][1].getUri());
- EXPECT_EQ(2, repout[0][1].size());
+ EXPECT_EQ(2u, repout[0][1].size());
EXPECT_EQ(inner3.getUri(), repout[0][1][0].getUri());
EXPECT_EQ(inner4.getUri(), repout[0][1][1].getUri());
- EXPECT_EQ(2, repout[1].size());
- EXPECT_EQ(2, repout[1][0].size());
+ EXPECT_EQ(2u, repout[1].size());
+ EXPECT_EQ(2u, repout[1][0].size());
EXPECT_EQ(inner5.getUri(), repout[1][0][0].getUri());
EXPECT_EQ(inner6.getUri(), repout[1][0][1].getUri());
- EXPECT_EQ(2, repout[1][1].size());
+ EXPECT_EQ(2u, repout[1][1].size());
EXPECT_EQ(inner7.getUri(), repout[1][1][0].getUri());
EXPECT_EQ(inner8.getUri(), repout[1][1][1].getUri());
- EXPECT_EQ(2, repout2.size());
- EXPECT_EQ(2, repout2[0].size());
- EXPECT_EQ(2, repout2[0][0].size());
+ EXPECT_EQ(2u, repout2.size());
+ EXPECT_EQ(2u, repout2[0].size());
+ EXPECT_EQ(2u, repout2[0][0].size());
EXPECT_EQ(inner1.getUri(), repout2[0][0][0].getUri());
EXPECT_EQ(inner2.getUri(), repout2[0][0][1].getUri());
- EXPECT_EQ(2, repout[0][1].size());
+ EXPECT_EQ(2u, repout[0][1].size());
EXPECT_EQ(inner3.getUri(), repout2[0][1][0].getUri());
EXPECT_EQ(inner4.getUri(), repout2[0][1][1].getUri());
- EXPECT_EQ(2, repout[1].size());
- EXPECT_EQ(2, repout[1][0].size());
+ EXPECT_EQ(2u, repout[1].size());
+ EXPECT_EQ(2u, repout[1][0].size());
EXPECT_EQ(inner5.getUri(), repout2[1][0][0].getUri());
EXPECT_EQ(inner6.getUri(), repout2[1][0][1].getUri());
- EXPECT_EQ(2, repout[1][1].size());
+ EXPECT_EQ(2u, repout[1][1].size());
EXPECT_EQ(inner7.getUri(), repout2[1][1][0].getUri());
EXPECT_EQ(inner8.getUri(), repout2[1][1][1].getUri());
double badout;
- EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
string badoutstr;
- EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
+ EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
(void)badout;
(void)badoutstr;
}
rep.setValue("bool", true);
rep.setValue("string", std::string("this is a string"));
- EXPECT_EQ(4, rep.size());
+ EXPECT_EQ(4u, rep.size());
EXPECT_FALSE(rep.empty());
OCRepresentation::const_iterator itr = rep.cbegin();
rep.setValue("bool", true);
rep.setValue("string", std::string("this is a string"));
- EXPECT_EQ(4, rep.size());
+ EXPECT_EQ(4u, rep.size());
EXPECT_FALSE(rep.empty());
for(const auto& a : rep)
rep.setValue("bool", true);
rep.setValue("string", std::string("this is a string"));
- EXPECT_EQ(4, rep.size());
+ EXPECT_EQ(4u, rep.size());
EXPECT_FALSE(rep.empty());
for(auto& cur : rep)
EXPECT_EQ("int", cur.attrname());
EXPECT_EQ(AttributeType::Integer, cur.type());
EXPECT_EQ(AttributeType::Integer, cur.base_type());
- EXPECT_EQ(0, cur.depth());
+ EXPECT_EQ(0u, cur.depth());
int curInt = cur.getValue<int>();
EXPECT_EQ(8, curInt);
}
EXPECT_EQ("double", cur.attrname());
EXPECT_EQ(AttributeType::Double, cur.type());
EXPECT_EQ(AttributeType::Double, cur.base_type());
- EXPECT_EQ(0, cur.depth());
+ EXPECT_EQ(0u, cur.depth());
double curDouble = cur.getValue<double>();
EXPECT_EQ(8.8, curDouble);
}
EXPECT_EQ("bool", cur.attrname());
EXPECT_EQ(AttributeType::Boolean, cur.type());
EXPECT_EQ(AttributeType::Boolean, cur.base_type());
- EXPECT_EQ(0, cur.depth());
+ EXPECT_EQ(0u, cur.depth());
bool curBool = cur.getValue<bool>();
EXPECT_EQ(true, curBool);
}
EXPECT_EQ("string", cur.attrname());
EXPECT_EQ(AttributeType::String, cur.type());
EXPECT_EQ(AttributeType::String, cur.base_type());
- EXPECT_EQ(0, cur.depth());
+ EXPECT_EQ(0u, cur.depth());
string curStr = cur.getValue<string>();
EXPECT_EQ("this is a string", curStr);
}
vector<vector<vector<OCRepresentation>>> repvvv{{{sub5},{sub6}},{{sub3},{sub2}}};
rep.setValue("repvvv", repvvv);
- EXPECT_EQ(20, rep.size());
+ EXPECT_EQ(20u, rep.size());
EXPECT_FALSE(rep.empty());
OCRepresentation::iterator itr= rep.begin();
EXPECT_EQ("int", itr->attrname());
EXPECT_EQ(AttributeType::Integer, itr->type());
EXPECT_EQ(AttributeType::Integer, itr->base_type());
- EXPECT_EQ(0, itr->depth());
+ EXPECT_EQ(0u, itr->depth());
int curInt = (*itr).getValue<int>();
EXPECT_EQ(8, curInt);
}
EXPECT_EQ("double", itr->attrname());
EXPECT_EQ(AttributeType::Double, itr->type());
EXPECT_EQ(AttributeType::Double, itr->base_type());
- EXPECT_EQ(0, itr->depth());
+ EXPECT_EQ(0u, itr->depth());
double curDouble = (*itr).getValue<double>();
EXPECT_EQ(8.8, curDouble);
}
EXPECT_EQ("bool", itr->attrname());
EXPECT_EQ(AttributeType::Boolean, itr->type());
EXPECT_EQ(AttributeType::Boolean, itr->base_type());
- EXPECT_EQ(0, itr->depth());
+ EXPECT_EQ(0u, itr->depth());
bool curBool = (*itr).getValue<bool>();
EXPECT_EQ(true, curBool);
}
EXPECT_EQ("string", itr->attrname());
EXPECT_EQ(AttributeType::String, itr->type());
EXPECT_EQ(AttributeType::String, itr->base_type());
- EXPECT_EQ(0, itr->depth());
+ EXPECT_EQ(0u, itr->depth());
string curString = (*itr).getValue<string>();
EXPECT_EQ("this is a string", curString);
}
EXPECT_EQ("rep", itr->attrname());
EXPECT_EQ(AttributeType::OCRepresentation, itr->type());
EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
- EXPECT_EQ(0, itr->depth());
+ EXPECT_EQ(0u, itr->depth());
OCRepresentation curRep = (*itr).getValue<OCRepresentation>();
EXPECT_EQ(sub1.getUri(), curRep.getUri());
}
EXPECT_EQ("intv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Integer, itr->base_type());
- EXPECT_EQ(1, itr->depth());
+ EXPECT_EQ(1u, itr->depth());
vector<int> curv = (*itr).getValue<vector<int>>();
EXPECT_EQ(intv, curv);
}
EXPECT_EQ("doublev", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Double, itr->base_type());
- EXPECT_EQ(1, itr->depth());
+ EXPECT_EQ(1u, itr->depth());
vector<double> curv = (*itr).getValue<vector<double>>();
EXPECT_EQ(doublev, curv);
}
EXPECT_EQ("boolv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Boolean, itr->base_type());
- EXPECT_EQ(1, itr->depth());
+ EXPECT_EQ(1u, itr->depth());
vector<bool> curv = (*itr).getValue<vector<bool>>();
EXPECT_EQ(boolv, curv);
}
EXPECT_EQ("strv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::String, itr->base_type());
- EXPECT_EQ(1, itr->depth());
+ EXPECT_EQ(1u, itr->depth());
vector<string> curv = (*itr).getValue<vector<string>>();
EXPECT_EQ(strv, curv);
}
EXPECT_EQ("repv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
- EXPECT_EQ(1, itr->depth());
+ EXPECT_EQ(1u, itr->depth());
vector<OCRepresentation> curv = (*itr).getValue<vector<OCRepresentation>>();
- EXPECT_EQ(2, repv.size());
+ EXPECT_EQ(2u, repv.size());
EXPECT_EQ(sub1.getUri(), repv[0].getUri());
EXPECT_EQ(sub2.getUri(), repv[1].getUri());
}
EXPECT_EQ("intvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Integer, itr->base_type());
- EXPECT_EQ(2, itr->depth());
+ EXPECT_EQ(2u, itr->depth());
vector<vector<int>> curv = (*itr).getValue<vector<vector<int>>>();
EXPECT_EQ(intvv, curv);
}
EXPECT_EQ("intvvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Integer, itr->base_type());
- EXPECT_EQ(3, itr->depth());
+ EXPECT_EQ(3u, itr->depth());
vector<vector<vector<int>>> curv = (*itr).getValue<vector<vector<vector<int>>>>();
EXPECT_EQ(intvvv, curv);
}
EXPECT_EQ("doublevv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Double, itr->base_type());
- EXPECT_EQ(2, itr->depth());
+ EXPECT_EQ(2u, itr->depth());
vector<vector<double>> curv = (*itr).getValue<vector<vector<double>>>();
EXPECT_EQ(doublevv, curv);
}
EXPECT_EQ("doublevvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Double, itr->base_type());
- EXPECT_EQ(3, itr->depth());
+ EXPECT_EQ(3u, itr->depth());
vector<vector<vector<double>>> curv =
(*itr).getValue<vector<vector<vector<double>>>>();
EXPECT_EQ(doublevvv, curv);
EXPECT_EQ("boolvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Boolean, itr->base_type());
- EXPECT_EQ(2, itr->depth());
+ EXPECT_EQ(2u, itr->depth());
vector<vector<bool>> curv = (*itr).getValue<vector<vector<bool>>>();
EXPECT_EQ(boolvv, curv);
}
EXPECT_EQ("boolvvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::Boolean, itr->base_type());
- EXPECT_EQ(3, itr->depth());
+ EXPECT_EQ(3u, itr->depth());
vector<vector<vector<bool>>> curv = (*itr).getValue<vector<vector<vector<bool>>>>();
EXPECT_EQ(boolvvv, curv);
}
EXPECT_EQ("strvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::String, itr->base_type());
- EXPECT_EQ(2, itr->depth());
+ EXPECT_EQ(2u, itr->depth());
vector<vector<string>> curv = (*itr).getValue<vector<vector<string>>>();
EXPECT_EQ(strvv, curv);
}
EXPECT_EQ("strvvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::String, itr->base_type());
- EXPECT_EQ(3, itr->depth());
+ EXPECT_EQ(3u, itr->depth());
vector<vector<vector<string>>> curv =
(*itr).getValue<vector<vector<vector<string>>>>();
EXPECT_EQ(strvvv, curv);
EXPECT_EQ("repvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
- EXPECT_EQ(2, itr->depth());
+ EXPECT_EQ(2u, itr->depth());
vector<vector<OCRepresentation>> curv =
(*itr).getValue<vector<vector<OCRepresentation>>>();
- EXPECT_EQ(2, curv.size());
- EXPECT_EQ(2, curv[0].size());
+ EXPECT_EQ(2u, curv.size());
+ EXPECT_EQ(2u, curv[0].size());
EXPECT_EQ(sub1.getUri(), curv[0][0].getUri());
EXPECT_EQ(sub2.getUri(), curv[0][1].getUri());
- EXPECT_EQ(2, curv[1].size());
+ EXPECT_EQ(2u, curv[1].size());
EXPECT_EQ(sub3.getUri(), curv[1][0].getUri());
EXPECT_EQ(sub4.getUri(), curv[1][1].getUri());
}
EXPECT_EQ("repvvv", itr->attrname());
EXPECT_EQ(AttributeType::Vector, itr->type());
EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
- EXPECT_EQ(3, itr->depth());
+ EXPECT_EQ(3u, itr->depth());
vector<vector<vector<OCRepresentation>>> curv =
(*itr).getValue<vector<vector<vector<OCRepresentation>>>>();
- EXPECT_EQ(2, curv.size());
- EXPECT_EQ(2, curv[0].size());
- EXPECT_EQ(1, curv[0][0].size());
+ EXPECT_EQ(2u, curv.size());
+ EXPECT_EQ(2u, curv[0].size());
+ EXPECT_EQ(1u, curv[0][0].size());
EXPECT_EQ(sub5.getUri(), curv[0][0][0].getUri());
- EXPECT_EQ(1, curv[0][1].size());
+ EXPECT_EQ(1u, curv[0][1].size());
EXPECT_EQ(sub6.getUri(), curv[0][1][0].getUri());
- EXPECT_EQ(1, curv[1][0].size());
+ EXPECT_EQ(1u, curv[1][0].size());
EXPECT_EQ(sub3.getUri(), curv[1][0][0].getUri());
- EXPECT_EQ(1, curv[1][1].size());
+ EXPECT_EQ(1u, curv[1][1].size());
EXPECT_EQ(sub2.getUri(), curv[1][1][0].getUri());
}
else
}
}
}
+
+ TEST(OCRepresentationHostTest, ValidHost)
+ {
+ OCDevAddr addr = {OC_DEFAULT_ADAPTER, OC_IP_USE_V6};
+ addr.port = 5000;
+ strcpy(addr.addr, "fe80::1%eth0");
+
+ OCRepresentation rep;
+ rep.setDevAddr(addr);
+ std::string host = rep.getHost();
+ std::string expected = "coap://[fe80::1%25eth0]:5000";
+ EXPECT_EQ(host, expected);
+ }
+
+ TEST(OCRepresentationHostTest, InvalidHost)
+ {
+ OCDevAddr addr = {OC_DEFAULT_ADAPTER, OC_IP_USE_V6};
+ addr.port = 5000;
+ strcpy(addr.addr, "fe80::1%%");
+
+ OCRepresentation rep;
+ EXPECT_ANY_THROW(rep.setDevAddr(addr));
+ }
+
}