[2302] Add ConstElementPtr version of tests for all types of Element

diff --git a/src/lib/cc/tests/data_unittests.cc b/src/lib/cc/tests/data_unittests.cc
index 30fa82de2be8e0d1119bf2134c79f46052d1f118..d66e24b3d4b8f8f8095ffd95d8f76780db214f1c 100644 (file)
--- a/src/lib/cc/tests/data_unittests.cc
+++ b/src/lib/cc/tests/data_unittests.cc
@@ -172,15 +172,14 @@ TEST(Element, from_and_to_json) {
 
 }
 
-TEST(Element, create_and_value_throws) {
-    // this test checks whether elements throw exceptions if the
-    // incorrect type is requested
-    ElementPtr el;
-    ConstElementPtr cel;
+template <typename T>
+void
+testGetValueInt() {
+    T el;
     long int i;
     double d;
     bool b;
-    std::string s("asdf");
+    std::string s;
     std::vector<ConstElementPtr> v;
     std::map<std::string, ConstElementPtr> m;
 
@@ -197,43 +196,19 @@ TEST(Element, create_and_value_throws) {
     EXPECT_FALSE(el->getValue(s));
     EXPECT_FALSE(el->getValue(v));
     EXPECT_FALSE(el->getValue(m));
-    EXPECT_EQ(i, 1);
-
-    cel = Element::create(1);
-    EXPECT_NO_THROW(cel->intValue());
-    EXPECT_THROW(cel->doubleValue(), TypeError);
-    EXPECT_THROW(cel->boolValue(), TypeError);
-    EXPECT_THROW(cel->stringValue(), TypeError);
-    EXPECT_THROW(cel->listValue(), TypeError);
-    EXPECT_THROW(cel->mapValue(), TypeError);
-    EXPECT_TRUE(cel->getValue(i));
-    EXPECT_FALSE(cel->getValue(d));
-    EXPECT_FALSE(cel->getValue(b));
-    EXPECT_FALSE(cel->getValue(s));
-    EXPECT_FALSE(cel->getValue(v));
-    EXPECT_FALSE(cel->getValue(m));
-    EXPECT_EQ(i, 1);
-
-    i = 2;
-    EXPECT_TRUE(el->setValue(i));
-    EXPECT_EQ(2, el->intValue());
-    EXPECT_FALSE(el->setValue(d));
-    EXPECT_FALSE(el->setValue(b));
-    EXPECT_FALSE(el->setValue(s));
-    EXPECT_FALSE(el->setValue(v));
-    EXPECT_FALSE(el->setValue(m));
-    EXPECT_THROW(el->get(1), TypeError);
-    EXPECT_THROW(el->set(1, el), TypeError);
-    EXPECT_THROW(el->add(el), TypeError);
-    EXPECT_THROW(el->remove(1), TypeError);
-    EXPECT_THROW(el->size(), TypeError);
-    EXPECT_THROW(el->get("foo"), TypeError);
-    EXPECT_THROW(el->set("foo", el), TypeError);
-    EXPECT_THROW(el->remove("foo"), TypeError);
-    EXPECT_THROW(el->contains("foo"), TypeError);
-    ConstElementPtr tmp;
-    EXPECT_FALSE(el->find("foo", tmp));
+    EXPECT_EQ(1, i);
+}
 
+template <typename T>
+void
+testGetValueDouble() {
+    T el;
+    long int i;
+    double d;
+    bool b;
+    std::string s;
+    std::vector<ConstElementPtr> v;
+    std::map<std::string, ConstElementPtr> m;
 
     el = Element::create(1.1);
     EXPECT_THROW(el->intValue(), TypeError);
@@ -248,15 +223,19 @@ TEST(Element, create_and_value_throws) {
     EXPECT_FALSE(el->getValue(s));
     EXPECT_FALSE(el->getValue(v));
     EXPECT_FALSE(el->getValue(m));
-    EXPECT_EQ(d, 1.1);
-    d = 2.2;
-    EXPECT_TRUE(el->setValue(d));
-    EXPECT_EQ(2.2, el->doubleValue());
-    EXPECT_FALSE(el->setValue(i));
-    EXPECT_FALSE(el->setValue(b));
-    EXPECT_FALSE(el->setValue(s));
-    EXPECT_FALSE(el->setValue(v));
-    EXPECT_FALSE(el->setValue(m));
+    EXPECT_EQ(1.1, d);
+}
+
+template <typename T>
+void
+testGetValueBool() {
+    T el;
+    long int i;
+    double d;
+    bool b;
+    std::string s;
+    std::vector<ConstElementPtr> v;
+    std::map<std::string, ConstElementPtr> m;
 
     el = Element::create(true);
     EXPECT_THROW(el->intValue(), TypeError);
@@ -271,10 +250,19 @@ TEST(Element, create_and_value_throws) {
     EXPECT_FALSE(el->getValue(s));
     EXPECT_FALSE(el->getValue(v));
     EXPECT_FALSE(el->getValue(m));
-    EXPECT_EQ(b, true);
-    b = false;
-    EXPECT_TRUE(el->setValue(b));
-    EXPECT_FALSE(el->boolValue());
+    EXPECT_EQ(true, b);
+}
+
+template <typename T>
+void
+testGetValueString() {
+    T el;
+    long int i;
+    double d;
+    bool b;
+    std::string s;
+    std::vector<ConstElementPtr> v;
+    std::map<std::string, ConstElementPtr> m;
 
     el = Element::create("foo");
     EXPECT_THROW(el->intValue(), TypeError);
@@ -289,10 +277,19 @@ TEST(Element, create_and_value_throws) {
     EXPECT_TRUE(el->getValue(s));
     EXPECT_FALSE(el->getValue(v));
     EXPECT_FALSE(el->getValue(m));
-    EXPECT_EQ(s, "foo");
-    s = "bar";
-    EXPECT_TRUE(el->setValue(s));
-    EXPECT_EQ("bar", el->stringValue());
+    EXPECT_EQ("foo", s);
+}
+
+template <typename T>
+void
+testGetValueList() {
+    T el;
+    long int i;
+    double d;
+    bool b;
+    std::string s;
+    std::vector<ConstElementPtr> v;
+    std::map<std::string, ConstElementPtr> m;
 
     el = Element::createList();
     EXPECT_THROW(el->intValue(), TypeError);
@@ -308,9 +305,18 @@ TEST(Element, create_and_value_throws) {
     EXPECT_TRUE(el->getValue(v));
     EXPECT_FALSE(el->getValue(m));
     EXPECT_EQ("[  ]", el->str());
-    v.push_back(Element::create(1));
-    EXPECT_TRUE(el->setValue(v));
-    EXPECT_EQ("[ 1 ]", el->str());
+}
+
+template <typename T>
+void
+testGetValueMap() {
+    T el;
+    long int i;
+    double d;
+    bool b;
+    std::string s;
+    std::vector<ConstElementPtr> v;
+    std::map<std::string, ConstElementPtr> m;
 
     el = Element::createMap();
     EXPECT_THROW(el->intValue(), TypeError);
@@ -325,7 +331,125 @@ TEST(Element, create_and_value_throws) {
     EXPECT_FALSE(el->getValue(s));
     EXPECT_FALSE(el->getValue(v));
     EXPECT_TRUE(el->getValue(m));
+}
+
+TEST(Element, create_and_value_throws) {
+    // this test checks whether elements throw exceptions if the
+    // incorrect type is requested
+    ElementPtr el;
+    ConstElementPtr cel;
+    long int i = 0;
+    double d = 0.0;
+    bool b = false;
+    std::string s("asdf");
+    std::vector<ConstElementPtr> v;
+    std::map<std::string, ConstElementPtr> m;
+    ConstElementPtr tmp;
+
+    testGetValueInt<ElementPtr>();
+    testGetValueInt<ConstElementPtr>();
+
+    el = Element::create(1);
+    i = 2;
+    EXPECT_TRUE(el->setValue(i));
+    EXPECT_EQ(2, el->intValue());
+    EXPECT_FALSE(el->setValue(d));
+    EXPECT_FALSE(el->setValue(b));
+    EXPECT_FALSE(el->setValue(s));
+    EXPECT_FALSE(el->setValue(v));
+    EXPECT_FALSE(el->setValue(m));
+    EXPECT_THROW(el->get(1), TypeError);
+    EXPECT_THROW(el->set(1, el), TypeError);
+    EXPECT_THROW(el->add(el), TypeError);
+    EXPECT_THROW(el->remove(1), TypeError);
+    EXPECT_THROW(el->size(), TypeError);
+    EXPECT_THROW(el->get("foo"), TypeError);
+    EXPECT_THROW(el->set("foo", el), TypeError);
+    EXPECT_THROW(el->remove("foo"), TypeError);
+    EXPECT_THROW(el->contains("foo"), TypeError);
+    EXPECT_FALSE(el->find("foo", tmp));
+
+    testGetValueDouble<ElementPtr>();
+    testGetValueDouble<ConstElementPtr>();
 
+    el = Element::create(1.1);
+    d = 2.2;
+    EXPECT_TRUE(el->setValue(d));
+    EXPECT_EQ(2.2, el->doubleValue());
+    EXPECT_FALSE(el->setValue(i));
+    EXPECT_FALSE(el->setValue(b));
+    EXPECT_FALSE(el->setValue(s));
+    EXPECT_FALSE(el->setValue(v));
+    EXPECT_FALSE(el->setValue(m));
+    EXPECT_THROW(el->get(1), TypeError);
+    EXPECT_THROW(el->set(1, el), TypeError);
+    EXPECT_THROW(el->add(el), TypeError);
+    EXPECT_THROW(el->remove(1), TypeError);
+    EXPECT_THROW(el->size(), TypeError);
+    EXPECT_THROW(el->get("foo"), TypeError);
+    EXPECT_THROW(el->set("foo", el), TypeError);
+    EXPECT_THROW(el->remove("foo"), TypeError);
+    EXPECT_THROW(el->contains("foo"), TypeError);
+    EXPECT_FALSE(el->find("foo", tmp));
+
+    testGetValueBool<ElementPtr>();
+    testGetValueBool<ConstElementPtr>();
+
+    el = Element::create(true);
+    b = false;
+    EXPECT_TRUE(el->setValue(b));
+    EXPECT_FALSE(el->boolValue());
+    EXPECT_FALSE(el->setValue(i));
+    EXPECT_FALSE(el->setValue(d));
+    EXPECT_FALSE(el->setValue(s));
+    EXPECT_FALSE(el->setValue(v));
+    EXPECT_FALSE(el->setValue(m));
+    EXPECT_THROW(el->get(1), TypeError);
+    EXPECT_THROW(el->set(1, el), TypeError);
+    EXPECT_THROW(el->add(el), TypeError);
+    EXPECT_THROW(el->remove(1), TypeError);
+    EXPECT_THROW(el->size(), TypeError);
+    EXPECT_THROW(el->get("foo"), TypeError);
+    EXPECT_THROW(el->set("foo", el), TypeError);
+    EXPECT_THROW(el->remove("foo"), TypeError);
+    EXPECT_THROW(el->contains("foo"), TypeError);
+    EXPECT_FALSE(el->find("foo", tmp));
+
+    testGetValueString<ElementPtr>();
+    testGetValueString<ConstElementPtr>();
+
+    el = Element::create("foo");
+    s = "bar";
+    EXPECT_TRUE(el->setValue(s));
+    EXPECT_EQ("bar", el->stringValue());
+    EXPECT_FALSE(el->setValue(i));
+    EXPECT_FALSE(el->setValue(b));
+    EXPECT_FALSE(el->setValue(d));
+    EXPECT_FALSE(el->setValue(v));
+    EXPECT_FALSE(el->setValue(m));
+    EXPECT_THROW(el->get(1), TypeError);
+    EXPECT_THROW(el->set(1, el), TypeError);
+    EXPECT_THROW(el->add(el), TypeError);
+    EXPECT_THROW(el->remove(1), TypeError);
+    EXPECT_THROW(el->size(), TypeError);
+    EXPECT_THROW(el->get("foo"), TypeError);
+    EXPECT_THROW(el->set("foo", el), TypeError);
+    EXPECT_THROW(el->remove("foo"), TypeError);
+    EXPECT_THROW(el->contains("foo"), TypeError);
+    EXPECT_FALSE(el->find("foo", tmp));
+
+    testGetValueList<ElementPtr>();
+    testGetValueList<ConstElementPtr>();
+
+    el = Element::createList();
+    v.push_back(Element::create(1));
+    EXPECT_TRUE(el->setValue(v));
+    EXPECT_EQ("[ 1 ]", el->str());
+
+    testGetValueMap<ElementPtr>();
+    testGetValueMap<ConstElementPtr>();
+
+    el = Element::createMap();
 }
 
 // Helper for escape check; it puts the given string in a StringElement,