parameter-framework: Drop of github upstream version v3.2.4

Main features are:
-Networking code may now be opted-out
     (for android build: no socket opened for user build)
-Get rid of python prebuild for XML generation

Bug: 22887211

Change-Id: Ieee49b439f694f14ce48c23127d34622691397ef
Signed-off-by: François Gaffie <francois.gaffie@intel.com>
Signed-off-by: David Wagner <david.wagner@intel.com>

1 files changed, 223 insertions, 0 deletions

diff --git a/utility/test/utility.cpp b/utility/test/utility.cpp
new file mode 100644
index 0000000..26be9e1
--- /dev/null
+++ b/utility/test/utility.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2011-2014, Intel Corporation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "Utility.h"
+#include "BinaryCopy.hpp"
+
+#include <catch.hpp>
+#include <functional>
+#include <map>
+
+using std::list;
+using std::string;
+
+namespace utility
+{
+
+SCENARIO("join<int>")
+{
+    struct Test
+    {
+        list<int> input;
+        std::function<int(int, int)> binaryOpt;
+        int empty;
+        int result;
+        int resultNoEmpty;
+    };
+    const list<Test> tests = {{{}, nullptr, 21, 21, 0},
+                              {{5}, nullptr, -1, 5, 5},
+                              {{5, 2}, [](int, int) { return 73; }, -1, 73, 73},
+                              {{2, 3, 7}, [](int l, int r) { return l * r; }, -1, 42, 42},
+                              {{1, 10, 100}, [](int l, int r) { return l + r; }, -1, 111, 111}};
+    for (auto &test : tests) {
+        CAPTURE(Catch::toString(test.input));
+        const auto &first = begin(test.input);
+        const auto &last = end(test.input);
+        REQUIRE(join(first, last, test.binaryOpt, test.empty) == test.result);
+        REQUIRE(join<int>(first, last, test.binaryOpt) == test.resultNoEmpty);
+    }
+}
+
+SCENARIO("asString(list)")
+{
+    struct Test
+    {
+        string title;
+        list<string> input;
+        string separator;
+        string result;
+        string resultNoSep;
+    };
+    const list<Test> tests = {
+        {"Empty list", {}, "aa", "", ""},
+        {"One element", {"a"}, "<>", "a", "a"},
+        {"Three elem list", {"1", "2", "3"}, "**", "1**2**3", "1\n2\n3"},
+        {"No separator", {"12", "ab", "+-"}, "", "12ab+-", "12\nab\n+-"},
+        {"empty elem list", {"a", "b", "", "d"}, "|", "a|b||d", "a\nb\n\nd"},
+    };
+    for (auto &test : tests) {
+        CAPTURE(Catch::toString(test.input));
+        WHEN ("Separator, " + test.title) {
+            CAPTURE(test.separator);
+            REQUIRE(asString(test.input, test.separator) == test.result);
+        }
+        THEN ("No separator, " + test.title) {
+            REQUIRE(asString(test.input) == test.resultNoSep);
+        }
+    }
+}
+
+SCENARIO("asString(map)")
+{
+    using std::map;
+
+    using Map = map<string, string>;
+    struct Test
+    {
+        Map input;
+        string itemSep;
+        string keyValueSep;
+        string result;
+        string resultNoKeyValueSep;
+        string resultNoSep;
+    };
+    const list<Test> tests = {{{}, "itemSep", "keyValueSep", "", "", ""},
+                              {
+                                  Map{{"a", "b"}, {"c", "d"}, {"e", "f"}}, // input
+                                  " - ", "\n",                             // item & keyValue sep
+                                  "a - b\nc - d\ne - f",                   // result
+                                  "a:b\nc:d\ne:f",                         // resultNoKeyValueSep
+                                  "a:b, c:d, e:f"                          // resultNoSep
+                              }};
+    for (const auto &test : tests) {
+        CAPTURE(Catch::toString(test.input));
+        CAPTURE(test.keyValueSep);
+        CAPTURE(test.itemSep);
+        REQUIRE(asString(test.input, test.keyValueSep, test.itemSep) == test.result);
+        REQUIRE(asString(test.input, test.keyValueSep) == test.resultNoKeyValueSep);
+        REQUIRE(asString(test.input) == test.resultNoSep);
+    }
+}
+
+SCENARIO("appendTitle")
+{
+    struct Test
+    {
+        string initial;
+        string title;
+        string result;
+    };
+    const list<Test> tests = {{"", "abc", "\nabc\n===\n"},
+                              {"start", "title", "start\ntitle\n=====\n"}};
+    for (auto &test : tests) {
+        auto quote = [](std::string toQuote) { return '"' + toQuote + '"'; };
+
+        GIVEN ("A title: " + quote(test.title)) {
+            CAPTURE(test.initial);
+            CAPTURE(test.title);
+
+            WHEN ("Appending to: " + quote(test.initial)) {
+                string output = test.initial;
+                THEN ("Result should be:\n" + quote(test.result)) {
+                    appendTitle(output, test.title);
+                    CHECK(output == test.result);
+                }
+            }
+        }
+    }
+}
+
+SCENARIO("isNotHexadecimal")
+{
+    for (auto &str : {"a", "0", "012", "13", "ABC", "Oxa"}) {
+        CAPTURE(str);
+        CHECK(not isHexadecimal(str));
+    }
+}
+
+SCENARIO("isHexadecimal")
+{
+    for (auto str : {"0xa", "0X0", "0x012", "0x13", "0xConsider as hexa as starting with 0x"}) {
+        CAPTURE(str);
+        CHECK(isHexadecimal(str));
+    }
+}
+
+template <class T1, class T2>
+void checkBinaryEqual(T1 v1, T2 v2)
+{
+    // For some yet-unknown reason, GCC 4.8 complains about
+    //     CHECK(a == b);
+    // and suggests that parentheses should be added. This is related to catch
+    // internals but such construcuts have been used without problem in lots of
+    // other places...
+    // Besides, GCC 4.9 does not seem to have a problem with that either.
+    // As a workaround, captures variables and parenthesize the expressions.
+
+    auto v2AsT1 = utility::binaryCopy<T1>(v2);
+    CAPTURE(v1);
+    CAPTURE(v2AsT1);
+    CHECK((v1 == v2AsT1));
+
+    auto v1AsT2 = utility::binaryCopy<T2>(v1);
+    CAPTURE(v2);
+    CAPTURE(v1AsT2);
+    CHECK((v2 == v1AsT2));
+}
+
+SCENARIO("binaryCopy bit exactness")
+{
+    GIVEN ("Integer representations computed using http://babbage.cs.qc.cuny.edu/IEEE-754/") {
+
+        THEN ("Floats should be coded on 32bits and fulfill IEEE-754."
+              " That assumption is made in the Parameter Framework.") {
+            REQUIRE(sizeof(float) == sizeof(uint32_t));
+            REQUIRE(std::numeric_limits<float>::is_iec559);
+        }
+        WHEN ("Testing float <=> uint32_t conversion") {
+            checkBinaryEqual<float, uint32_t>(1.23456f, 0x3f9e0610);
+        }
+
+        THEN ("Doubles should be coded on 64bits and fulfill IEEE-754."
+              " That assumption is made in the Parameter Framework.") {
+            REQUIRE(sizeof(double) == sizeof(uint64_t));
+            REQUIRE(std::numeric_limits<double>::is_iec559);
+        }
+        WHEN ("Testing double <=> uint64_t conversion") {
+            checkBinaryEqual<double, uint64_t>(987.65432109876, 0x408edd3c0cb3420e);
+        }
+    }
+
+    WHEN ("Testing int8_t <=> uint8_t conversion") {
+        checkBinaryEqual<int8_t, uint8_t>(-1, 0xff);
+    }
+}
+
+} // namespace utility