Test ElementHandle::setAs for booleans

It was not tested.

Signed-off-by: Kevin Rocard <[email protected]>

Author: krocard

parameter/include/ElementHandle.h

@@ -177,7 +177,7 @@ class PARAMETER_EXPORT ElementHandle
 
     /** Access (get or set) parameters as different types.
      *
-     * Will fail if the element is not a paramete.
+     * Will fail if the element is not a parameter.
      * Array access will fail if the parameter is not an array.
      *
      * @param value if get, the value to get (in parameter)
@@ -233,15 +233,35 @@ class PARAMETER_EXPORT ElementHandle
     /** @} */
 
 protected:
+    /** Friend to be constructed from CParameterMgr::createElementHandle. */
+    friend CParameterMgr;
+
+    /** Protected for test purposes.
+     * Client must not inherit from this class anyway.
+     * @{ */
     ElementHandle(CConfigurableElement &element, CParameterMgr &parameterMgr);
-    friend CParameterMgr; // So that it can build the handler
 
-private:
+    /** Access a parameter with a template type
+     *
+     * Template version of getAsBoolean, getAsInteger, getAsDoubleArray...
+     *
+     * @tparam T How to access the parameter.
+     *         Eg: use bool to call setAsBoolean
+     *             use std::vector<bool> to call setAsBooleanArray
+     *
+     * @note Why are those two methods not public ?
+     *       It could depreciate all the other setAs* and getAs*
+     * @{
+     */
     template <class T>
     bool setAs(const T value, std::string &error) const;
     template <class T>
     bool getAs(T &value, std::string &error) const;
+    /** @} */
 
+    /** @} */
+
+private:
     template <class T>
     static size_t getSize(T value);
     template <class T>

test/functional-tests/Handle.cpp

@@ -602,4 +602,33 @@ SCENARIO("Mapping handle access", "[handler][mapping]")
     }
 }
 
+SCENARIO_METHOD(AllParamsPF, "Access boolean", "[handler][access]")
+{
+    ElementHandle handle(*this, "/test/test/bool");
+    struct TestVector
+    {
+        bool expectedValue;
+        list<string> values;
+    };
+    list<TestVector> testVectors = {
+        {true, {"1", "0x1", "001", "0x001", "true", "True", "TRUe"}},
+        {false, {"0", "0x0", "000", "0x000", "false", "False", "FaLSe"}}};
+
+    for (auto testVector : testVectors) {
+        for (auto value : testVector.values) {
+            CAPTURE(value);
+            auto expectedValue = testVector.expectedValue;
+            CAPTURE(expectedValue);
+
+            CHECK_NOTHROW(handle.setAs(value));
+            CHECK(handle.getAs<decltype(value)>() == std::to_string(expectedValue));
+            CHECK(handle.getAs<decltype(expectedValue)>() == expectedValue);
+        }
+    }
+
+    for (string invalid : {"2", "-1", "0x10", "None", "faux"}) {
+        CHECK_THROWS_AS(handle.setAs(invalid), Exception);
+    }
+}
+
 } // namespace parameterFramework

test/functional-tests/include/ElementHandle.hpp

@@ -41,8 +41,12 @@ namespace parameterFramework
  * Contrary to ::ElementHandle, is constructed through it's constructor
  * and not a factory method.
  * @see parameterFramework::ParameterFramework for the main PF interface.
+ *
+ * @fixme Should privately inherit from FailureWrapper but this can not be done
+ *        as this class uses protected ::ElementHandle::getAs and setAs methods.
+ *        See their documentation for more information.
  */
-class ElementHandle : private FailureWrapper<::ElementHandle>
+class ElementHandle : protected FailureWrapper<::ElementHandle>
 {
     ElementHandle(const ElementHandle &other) = delete;
     ElementHandle &operator=(const ElementHandle &other) = delete;
@@ -71,6 +75,20 @@ class ElementHandle : private FailureWrapper<::ElementHandle>
         return value;
     }
 
+    /** Wrap EH::setAs* to throw an exception on failure. */
+    template <class T>
+    void setAs(T value)
+    {
+        mayFailCall(&EH::setAs<T>, value);
+    }
+
+    /** Wrap EH::getAs* to throw an exception on failure.
+     * @todo list allowed types. */
+    template <class T>
+    T getAs()
+    {
+        return mayFailGet(&EH::getAs<T>);
+    }
     /** Wrap EH::setAsDouble to throw an exception on failure. */
     void setAsDouble(double value) { mayFailCall(&EH::setAsDouble, value); }
     /** Wrap EH::getAsDouble to throw an exception on failure. */

test/xml-generator/testVector/complex.pfw

@@ -37,4 +37,4 @@ domainGroup: Red sequenceAware
 								q2.5 = 1.18750
 								string = 12 ab @ 	 <![CDATA[ < > \n \0 ✔ "'\
 							component: included
-								bool = 1
+								bool = true