#ifndef TEST_BITS_HPP
#define TEST_BITS_HPP
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include "msg.hpp"
#include "proton/types.hpp"

#include <stdexcept>
#include <iostream>
#include <iterator>
#include <sstream>
#include <cstring>
#include <math.h>

namespace test {

struct fail : public std::logic_error {
    explicit fail(const std::string& what) : logic_error(what) {}
};

struct error : public std::logic_error {
    explicit error(const std::string& what) : logic_error(what) {}
};

template <class T, class U>
void assert_equal(const T& want, const U& got, const std::string& what) {
    if (!(want == got))
        throw fail(MSG(what << " " << want << " != " << got));
}

template <class T>
inline void assert_equalish(T want, T got, T delta, const std::string& what)
{
    if (!(fabs(want-got) <= delta))
        throw fail(MSG(what << " " << want << " !=~ " << got));
}

void assert_substring(const std::string& want, const std::string& got, const std::string& what) {
    if (got.find(want) == std::string::npos)
        throw fail(MSG(what << " '" << want << "' not found in '" << got << "'"));
}

#define FAIL_MSG(WHAT) (MSG(__FILE__ << ":" << __LINE__ << ": " << WHAT).str())
#define FAIL(WHAT) throw test::fail(FAIL_MSG(WHAT))
#define ASSERT(TEST) do { if (!(TEST)) FAIL("failed ASSERT(" #TEST ")"); } while(false)
#define ASSERT_EQUAL(WANT, GOT) \
    test::assert_equal((WANT), (GOT), FAIL_MSG("failed ASSERT_EQUAL(" #WANT ", " #GOT ")"))
#define ASSERT_EQUALISH(WANT, GOT, DELTA) \
    test::assert_equalish((WANT), (GOT), (DELTA), FAIL_MSG("failed ASSERT_EQUALISH(" #WANT ", " #GOT ")"))
#define ASSERT_SUBSTRING(WANT, GOT) \
    test::assert_substring((WANT), (GOT), FAIL_MSG("failed ASSERT_SUBSTRING(" #WANT ", " #GOT ")"))
#define ASSERT_THROWS(WANT, EXPR) do { try { EXPR; FAIL("Expected " #WANT); } catch(const WANT&) {} } while(0)
#define ASSERT_THROWS_MSG(CLASS, MSG, EXPR) do { try { EXPR; FAIL("Expected " #CLASS); } catch(const CLASS& e) { ASSERT_SUBSTRING((MSG), e.what()); } } while(0)

#define RUN_TEST(BAD_COUNT, TEST)                                       \
    do {                                                                \
        try {                                                           \
            std::cout << "TEST: " << #TEST << std::endl;                \
            TEST;                                                       \
            break;                                                      \
        } catch(const test::fail& e) {                                  \
            std::cout << "FAIL " << #TEST << std::endl << e.what() << std::endl; \
        } catch(const std::exception& e) {                              \
            std::cout << "ERROR " << #TEST << std::endl << __FILE__ << ":" << __LINE__ << ": " << e.what() << std::endl; \
        } catch(...) {                                                  \
            std::cout << "ERROR " << #TEST << std::endl << __FILE__ << ":" << __LINE__ << ": (unknown)" << std::endl; \
        }                                                               \
        ++BAD_COUNT;                                                    \
    } while(0)

/* Like RUN_TEST but only if one of the argv strings is found in the test EXPR */
#define RUN_ARGV_TEST(BAD_COUNT, EXPR) do {     \
    if (argc == 1) {                            \
      RUN_TEST(BAD_COUNT, EXPR);                \
    } else {                                    \
      for (int i = 1; i < argc; ++i) {          \
        if (strstr(#EXPR, argv[i])) {           \
            RUN_TEST(BAD_COUNT, EXPR);          \
          break;                                \
        }                                       \
      }                                         \
    }                                           \
  } while(0)


template<class T> std::string str(const T& x) {
    std::ostringstream s; s << std::boolalpha << x; return s.str();
}

// A way to easily create literal collections that can be compared to std:: collections
// and to print std collections
// e.g.
//     std::vector<string> v = ...;
//     ASSERT_EQUAL(many<string>() + "a" + "b" + "c", v);
template <class T> struct many : public std::vector<T> {
    many() {}
    template<class S> explicit many(const S& s) : std::vector<T>(s.begin(), s.end()) {}
    many& operator+=(const T& t) { this->push_back(t); return *this; }
    many& operator<<(const T& t) { return *this += t; }
    many operator+(const T& t) { many<T> l(*this); return l += t; }
};

template <class T, class S> bool operator==(const many<T>& m, const S& s) {
    return m.size() == s.size() && S(m.begin(), m.end()) == s;
}

template <class T, class S> bool operator==(const S& s, const many<T>& m) {
    return m.size() == s.size() && S(m.begin(), m.end()) == s;
}

template <class T> std::ostream& operator<<(std::ostream& o, const many<T>& m) {
    std::ostream_iterator<T> oi(o, " ");
    std::copy(m.begin(), m.end(), oi);
    return o;
}

}

namespace std {
template <class T> std::ostream& operator<<(std::ostream& o, const std::vector<T>& s) {
    return o << test::many<T>(s);
}

template <class T> std::ostream& operator<<(std::ostream& o, const std::deque<T>& s) {
    return o << test::many<T>(s);
}

template <class T> std::ostream& operator<<(std::ostream& o, const std::list<T>& s) {
    return o << test::many<T>(s);
}

template <class K, class T> std::ostream& operator<<(std::ostream& o, const std::map<K, T>& x) {
    return o << test::many<std::pair<K, T> >(x);
}

template <class U, class V> std::ostream& operator<<(std::ostream& o, const std::pair<U, V>& p) {
    return o << "( " << p.first << " , " << p.second << " )";
}

template <class K, class T> std::ostream& operator<<(std::ostream& o, const std::unordered_map<K, T>& x) {
    return o << test::many<std::pair<const K, T> >(x);
}

template <class T> std::ostream& operator<<(std::ostream& o, const std::forward_list<T>& s) {
    return o << test::many<T>(s);
}

}

#endif // TEST_BITS_HPP
