/*
* 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