test_tools.h

 
#ifndef _TestTools_h_
#define _TestTools_h_
 
#include <functional>
#include <type_traits>
#include <iterator>
 
#include "system/object.h"
#include "system/object_ext.h"
#include "system/string.h"
#include "system/constraints.h"
#include "system/text/string_builder.h"
#include "system/collections/icollection.h"
#include "system/collections/ienumerable.h"
#include "system/collections/dictionary.h"
#include "system/collections/keyvalue_pair.h"
 
namespace System {
 
 
template <typename TT, typename T>
class IEnumeratorIterator : public Details::BaseIterator<std::input_iterator_tag, TT> {
public:
    IEnumeratorIterator(const System::SharedPtr<System::Collections::Generic::IEnumerator<T>>& data) : m_data(data) {};
    IEnumeratorIterator(const IEnumeratorIterator& o) : m_data(o.m_data) {};
 
    IEnumeratorIterator& operator++() { if (!m_data->MoveNext()) m_data = nullptr; return *this; }
    TT operator*() { return TT(m_data->get_Current()); };
 
    bool operator==(const IEnumeratorIterator& o) const { return m_data == o.m_data; }
    bool operator!=(const IEnumeratorIterator& o) const { return m_data != o.m_data; }
 
private:
    System::SharedPtr<System::Collections::Generic::IEnumerator<T>> m_data;
};
 
template <typename TT, typename T>
class IEnumerableAdapter
{
public:
    using value_type = TT;
    using const_iterator = IEnumeratorIterator<TT, T>;
 
    IEnumerableAdapter() : m_data(nullptr) {}
    IEnumerableAdapter(const System::SharedPtr<System::Collections::Generic::IEnumerable<T>>& data) : m_data(data->GetEnumerator()) {};
 
    IEnumeratorIterator<TT, T> begin() const
    {
        return m_data->MoveNext() ? IEnumeratorIterator<TT, T>(m_data) : IEnumeratorIterator<TT, T>(nullptr);
    }
    IEnumeratorIterator<TT, T> end() const { return IEnumeratorIterator<TT, T>(nullptr); }
 
private:
    System::SharedPtr<System::Collections::Generic::IEnumerator<T>> m_data;
};
 
template <typename TT, class Guard = typename std::enable_if<System::Constraints::IsStdTuple<TT>::value>::type,
          typename T = typename std::tuple_element<0, TT>::type>
class IEnumerableTupleAdapter : public IEnumerableAdapter<TT, T>
{
public:
    IEnumerableTupleAdapter(const System::SharedPtr<System::Collections::Generic::IEnumerable<T>>& data) :
        IEnumerableAdapter<TT, T>(data)
    {
    }
};
 
template <typename T>
class IEnumerableDefaultAdapter : public IEnumerableAdapter<T, T>
{
public:
    IEnumerableDefaultAdapter(const System::SharedPtr<System::Collections::Generic::IEnumerable<T>>& data) :
        IEnumerableAdapter<T, T>(data)
    {
    }
};
 
 
struct TestTools
{
 
template <typename T>
static typename std::enable_if<std::is_arithmetic<T>::value || std::is_enum<T>::value, bool>::type IsNull(T obj)
{
    return false;
}
template <typename T>
static typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_enum<T>::value, bool>::type IsNull(const T &obj)
{
    return obj == nullptr;
}
template <typename T>
static bool IsNull(const SharedPtr<T>& obj)
{
    return obj == nullptr;
}
template<typename K, typename V>
static  bool IsNull(System::Collections::Generic::KeyValuePair<K, V> & kvp)
{
    return kvp == nullptr;
}
 
static bool IsEmpty(const System::String& str)
{
    return str.IsEmpty();
}
template <typename T>
static bool IsEmpty(const SharedPtr<T>& collection)
{
    return collection->get_Count() == 0;
}
 
template <typename T>
static bool IsNullOrEmpty(const SharedPtr<T>& collection)
{
    return collection == nullptr || collection->get_Count() == 0;
}
static bool IsNullOrEmpty(const System::String& str)
{
    return str.IsNullOrEmpty();
}
 
static bool IsNull(const System::String& str)
{
    return str.IsNull();
}
 
static bool AssertThrows(const std::function<void()>& func)
{
    try
    {
        func();
    }
    catch (...) {
        return true;
    }
    return false;
}
 
}; // namespace TestTools
 
struct CollectionAssertHelper
{
    template <typename T1, typename T2>
    static System::SharedPtr<System::Collections::Generic::Dictionary<T1, int32_t>> MakeDiff(const System::SharedPtr<System::Collections::Generic::IEnumerable<T1>>& expected, const System::SharedPtr<System::Collections::Generic::IEnumerable<T2>>& actual)
    {
        auto diff = System::MakeObject<System::Collections::Generic::Dictionary<T1, int32_t>>();
 
        auto e_enumerator = (expected)->GetEnumerator();
        while (e_enumerator->MoveNext())
        {
            auto&& e = e_enumerator->get_Current();
            int32_t v;
            if (diff->TryGetValue(e, v))
            {
                diff->idx_set(e, v + 1);
            }
            else
            {
                diff->Add(e, 1);
            }
        }
 
        auto a_enumerator = (actual)->GetEnumerator();
        while (a_enumerator->MoveNext())
        {
            auto&& a = a_enumerator->get_Current();
            int32_t v;
            const auto aa = static_cast<T1>(a);
            if (diff->TryGetValue(aa, v))
            {
                diff->idx_set(aa, v - 1);
            }
            else
            {
                diff->Add(aa, -1);
            }
        }
        return diff;
    }
 
    static bool CheckDiffForAll(const std::function<bool(int)>& pred, const System::SharedPtr<System::Collections::Generic::ICollection<int32_t>>& values)
    {
        auto v_enumerator = (values)->GetEnumerator();
        while (v_enumerator->MoveNext())
        {
            auto&& v = v_enumerator->get_Current();
            if (!pred(v))
            {
                return false;
            }
        }
        return true;
    }
    static bool CheckDiffForAny(const std::function<bool(int)>& pred, const System::SharedPtr<System::Collections::Generic::ICollection<int32_t>>& values)
    {
        auto v_enumerator = (values)->GetEnumerator();
        while (v_enumerator->MoveNext())
        {
            auto&& v = v_enumerator->get_Current();
            if (pred(v))
            {
                return true;
            }
        }
        return false;
    }
 
    template <typename T>
    static System::String IEnumerableToStr(const System::SharedPtr<System::Collections::Generic::IEnumerable<T>>& ie)
    {
        if (ie == nullptr || !ie->GetEnumerator()->MoveNext())
        {
            return u"";
        }
 
        System::SharedPtr<System::Text::StringBuilder> sb = System::MakeObject<System::Text::StringBuilder>();
 
        auto e_enumerator = (ie)->GetEnumerator();
        while (e_enumerator->MoveNext())
        {
            auto&& e = e_enumerator->get_Current();
            sb->Append(System::ObjectExt::ToString(e))->Append(u", ");
        }
 
        sb->Remove(sb->get_Length() - 2, 2);
 
        return sb->ToString();
    }
 
    template <typename T1, typename T2>
    static System::String CollectionsToMsg(const System::String& extra_msg,
                                        const System::SharedPtr<System::Collections::Generic::IEnumerable<T1>>& expected,
                                        const System::SharedPtr<System::Collections::Generic::IEnumerable<T2>>& actual)
    {
        return u"\r\nExpected: " + extra_msg + u"< " + IEnumerableToStr(expected) + u" >" + 
               u"\r\nActual: < " + IEnumerableToStr(actual) + u" >";
    }
 
    static System::String ToFullMessage(const System::String& message = u"")
    {
        return System::String(u"Message: ") + (message.IsEmpty() ? u"<empty>" : message);
    }
};
 
} // namespace System
 
#define COLLECTION_ASSERT_MAKE_DIFF(expected, actual) ((System::CollectionAssertHelper::MakeDiff<std::remove_const<std::remove_reference<decltype((expected)->GetEnumerator()->get_Current())>::type>::type, std::remove_const<std::remove_reference<decltype((actual)->GetEnumerator()->get_Current())>::type>::type>((expected), (actual)))->get_Values())
#define COLLECTION_ASSERT_COLLECTIONS_TO_MSG(str, expected, actual) (System::CollectionAssertHelper::CollectionsToMsg<std::remove_const<std::remove_reference<decltype((expected)->GetEnumerator()->get_Current())>::type>::type, std::remove_const<std::remove_reference<decltype((actual)->GetEnumerator()->get_Current())>::type>::type>((str), (expected), (actual)))
 
#define COLLECTION_ASSERT_ARE_EQUIVALENT(expected, actual, ...) {\
    if (!System::CollectionAssertHelper::CheckDiffForAll([](int32_t v) {return v == 0;}, COLLECTION_ASSERT_MAKE_DIFF(expected, actual)))\
        FAIL() << (System::CollectionAssertHelper::ToFullMessage(__VA_ARGS__) + COLLECTION_ASSERT_COLLECTIONS_TO_MSG(u"equivalent to ", expected, actual)).ToUtf8String();\
}
 
#define COLLECTION_ASSERT_ARE_NOT_EQUIVALENT(expected, actual, ...) {\
    if (!System::CollectionAssertHelper::CheckDiffForAny([](int32_t v) {return v != 0;}, COLLECTION_ASSERT_MAKE_DIFF(expected, actual)))\
        FAIL() << (System::CollectionAssertHelper::ToFullMessage(__VA_ARGS__) + COLLECTION_ASSERT_COLLECTIONS_TO_MSG(u"not equivalent to ", expected, actual)).ToUtf8String();\
}
 
#define COLLECTION_ASSERT_IS_SUBSET_OF(subset, superset, ...) {\
    if (!System::CollectionAssertHelper::CheckDiffForAll([](int32_t v) {return v >= 0;}, COLLECTION_ASSERT_MAKE_DIFF(superset, subset)))\
        FAIL() << (System::CollectionAssertHelper::ToFullMessage(__VA_ARGS__) + COLLECTION_ASSERT_COLLECTIONS_TO_MSG(u"subset of ", superset, subset)).ToUtf8String();\
}
 
#define COLLECTION_ASSERT_IS_NOT_SUBSET_OF(subset, superset, ...) {\
    if (!System::CollectionAssertHelper::CheckDiffForAny([](int32_t v) {return v < 0;}, COLLECTION_ASSERT_MAKE_DIFF(superset, subset)))\
        FAIL() << (System::CollectionAssertHelper::ToFullMessage(__VA_ARGS__) + COLLECTION_ASSERT_COLLECTIONS_TO_MSG(u"not subset of ", superset, subset)).ToUtf8String();\
}
 
#define TEST_IF_CASE_HAS(member, name) \
    template<typename T> struct has_##member \
    { \
    private: \
        static int detect(...); \
        template<typename U> static decltype(void(std::declval<U>().name)) detect(const U&); \
    public: \
        static constexpr bool value = std::is_same<void, decltype(detect(std::declval<T>()))>::value; \
    };
 
 
#define TEST_IF_STATIC_METHOD(name) \
    template<typename T> struct is_static_method \
    { \
    private: \
        static int detect(...); \
        template<typename U> static typename std::enable_if<std::is_function<decltype(U::name)>::value, bool>::type detect(const U&); \
    public: \
        static constexpr bool value = std::is_same<bool, decltype(detect(std::declval<T>()))>::value; \
    };\
 
#define TEST_IF_STATIC_METHOD_NAMED(name) \
    template<typename T> struct is_static_method_##name \
    { \
    private: \
        static int detect(...); \
        template<typename U> static typename std::enable_if<std::is_function<decltype(U::name)>::value, bool>::type detect(const U&); \
    public: \
        static constexpr bool value = std::is_same<bool, decltype(detect(std::declval<T>()))>::value; \
    };\
 
#endif // _TestTools_h_