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