test_predicates.h

 
#pragma once
 
#include <gtest/gtest.h>
 
#include "system/shared_ptr.h"
#include "system/decimal.h"
#include "system/array.h"
#include "system/collections/list.h"
#include "system/collections/dictionary.h"
#include "system/collections/sorted_dictionary.h"
#include "system/collections/sorted_list.h"
#include "system/collections/stack.h"
#include "system/collections/queue.h"
#include "system/collections/bitarray.h"
#include "system/collections/specialized/string_collection.h"
#include "system/collections/hashset.h"
#include "system/object_ext.h"
 
#include "system/test_tools/test_tools.h"
#include "system/test_tools/compare.h"
 
#include <algorithm>
#include <cmath>
 
namespace System
{
namespace TestPredicates
{
namespace TypeTraits
{
 
template<typename T1, typename T2>
using AreFPandArithmetic = std::integral_constant<bool, (std::is_floating_point<T1>::value && std::is_arithmetic<T2>::value) || (std::is_arithmetic<T1>::value && std::is_floating_point<T2>::value) >;
 
template<typename T1, typename T2>
using AnyOfDecimal = std::integral_constant<bool, std::is_same<T1, System::Decimal>::value || std::is_same<T2, System::Decimal>::value>;
 
template<typename T1, typename T2, typename Enable = void>
struct LargestFPType {};
template<typename T1, typename T2>
struct LargestFPType<T1, T2, typename std::enable_if<std::is_floating_point<T1>::value && !std::is_floating_point<T2>::value>::type>
{
    using type = T1;
};
template<typename T1, typename T2>
struct LargestFPType<T1, T2, typename std::enable_if<std::is_floating_point<T2>::value && !std::is_floating_point<T1>::value>::type>
{
    using type = T2;
};
template<typename T1, typename T2>
struct LargestFPType<T1, T2, typename std::enable_if<std::is_floating_point<T1>::value && std::is_floating_point<T2>::value>::type>
{
    using type = typename std::conditional<sizeof(T1) >= sizeof(T2), T1, T2>::type;
};
 
template<typename T, typename Enable = void>
struct has_print_to_method : std::false_type {};
template<typename T>
struct has_print_to_method<
    T
    , decltype((void)(PrintTo(std::declval<T&>(), std::declval<std::ostream*>())))
> : std::true_type {};
 
template<typename T, typename Enable = void>
struct has_data_method : std::false_type {};
template<typename T>
struct has_data_method<
    T
    , decltype((void)(std::declval<T>().data()))
> : std::true_type {};
template<>
struct has_data_method<
    System::Collections::BitArray
    , void
> : std::false_type {}; // Forcing to false as boost types ain't accessible there
 
template<typename T>
using IsArray = std::is_same<T, System::Array<typename T::ValueType>>;
 
template<typename T>
using IsList = std::is_same<T, System::Collections::Generic::List<typename T::ValueType>>;
 
template<typename T1, typename T2>
using BothArrayOrList = std::integral_constant<bool, (IsArray<T1>::value || IsList<T1>::value) && (IsArray<T2>::value || IsList<T2>::value)>;
 
template<typename T, typename Enable = void>
struct IsEnumerable : std::false_type {};
template<typename T>
struct IsEnumerable<
    T
    , decltype((void)(std::declval<typename T::ValueType>()))
> : std::is_base_of<System::Collections::Generic::IEnumerable<typename T::ValueType>, T> {};
 
template <typename T1, typename T2>
using BothEnumerable = std::integral_constant<bool, IsEnumerable<T1>::value && IsEnumerable<T2>::value>;
 
       
template<typename T, typename Enable = void>
struct IsCppContainer : std::false_type {};
template<typename T>
struct IsCppContainer<
    T
    , decltype(std::declval<typename T::iterator>(), std::declval<typename T::const_iterator>(), void(0))
> : std::true_type {};
 
} // namespace TypeTraits
 
namespace Details
{
 
template<typename T>
std::enable_if_t<!TypeTraits::IsEnumerable<T>::value, std::string>
PrintToString(const T&);
 
template<typename T>
std::enable_if_t<TypeTraits::IsEnumerable<T>::value, std::string>
PrintToString(const T& value);
 
std::string PrintToString(std::nullptr_t);
std::string PrintToString(const Collections::Generic::IEnumerable<bool>&);
 
template<typename T>
typename std::enable_if<System::Details::HasToString<T>::value, std::string>::type
PrintToStringImpl(const SharedPtr<T>& value, long long s)
{
    if (value)
    {
        return value->ToString().ToUtf8String();
    }
 
    return "nullptr";
}
template<typename T>
typename std::enable_if<System::Details::HasToString<T>::value, std::string>::type
PrintToStringImpl(const WeakPtr<T>& value, long long s)
{
    if (auto ptr = value.lock())
    {
        return ptr->ToString().ToUtf8String();
    }
 
    return "nullptr";
}
template<typename T>
typename std::enable_if<!TypeTraits::has_print_to_method<T>::value && System::Details::HasToString<T>::value, std::string>::type
PrintToStringImpl(const T& value, long long s)
{
    ASPOSE_UNUSED(s);
    return const_cast<T&>(value).ToString().ToUtf8String();
}
template<typename T>
typename std::enable_if<TypeTraits::has_print_to_method<T>::value && !TypeTraits::IsEnumerable<T>::value, std::string>::type
PrintToStringImpl(const T& value, long long s)
{
    ASPOSE_UNUSED(s);
    ::std::stringstream ss;
    PrintTo(value, &ss);
    return ss.str();
}
template<typename T>
typename std::enable_if<TypeTraits::has_print_to_method<T>::value && TypeTraits::IsEnumerable<T>::value, std::string>::type
PrintToStringImpl(const T& value, long long s)
{
    ASPOSE_UNUSED(s);
    return PrintToString(static_cast<const Collections::Generic::IEnumerable<typename T::ValueType>&>(value));
}
template<typename T1, typename T2>
std::string PrintToStringImpl(const std::pair<T1, T2>& value, long long s)
{
    ASPOSE_UNUSED(s);
    std::ostringstream os;
    os << '(' << PrintToString(value.first) << ", " << PrintToString(value.second) << ')';
    return os.str();
}
template<typename T1, typename T2>
std::string PrintToStringImpl(const Collections::Generic::KeyValuePair<T1, T2>& value, long long s)
{
    ASPOSE_UNUSED(s);
    std::ostringstream os;
    os << '(' << PrintToString(value.get_Key()) << ", " << PrintToString(value.get_Value()) << ')';
    return os.str();
}
template<typename T>
typename std::enable_if<TypeTraits::IsCppContainer<T>::value && !std::is_base_of<Object, T>::value, std::string>::type
PrintToStringImpl(const T& container, long long s)
{
    ASPOSE_UNUSED(s);
    std::ostringstream ostr;
    const size_t kMaxCount = 32; // The maximum number of elements to print
    ostr << '{';
 
    size_t count = 0;
    for (auto it = container.begin();
        it != container.end(); ++it, ++count) {
        if (count > 0) {
            ostr << ',';
            if (count == kMaxCount) {  // Enough has been printed.
                ostr << " ...";
                break;
            }
        }
        ostr << ' ';
        ostr << PrintToString(*it);
    }
 
    if (count > 0) {
        ostr << ' ';
    }
    ostr << '}';
 
    return ostr.str();
}
template<typename T>
std::string PrintToStringImpl(const T& value, int s)
{
    ASPOSE_UNUSED(s);
    return ::testing::PrintToString(value);
}
template<typename T>
std::enable_if_t<!TypeTraits::IsEnumerable<T>::value, std::string>
PrintToString(const T& value)
{
    return PrintToStringImpl(value, 1LL);
}
inline std::string PrintToString(std::nullptr_t)
{
    return "nullptr";
}
inline std::string PrintToString(const Collections::Generic::IEnumerable<bool>& value)
{
    std::ostringstream ostr;
    const size_t kMaxCount = 32; // The maximum number of elements to print
    size_t count = 0;
 
    auto enumerator = const_cast<Collections::Generic::IEnumerable<bool>&>(value).GetEnumerator();
    while (enumerator->MoveNext())
    {
        if (count > 0)
        {
            if (count == kMaxCount)
            {
                // Enough has been printed.
                ostr << " ...";
                break;
            }
        }
        ++count;
        ostr << enumerator->get_Current();
    }
    return ostr.str();
}
template<typename T>
std::enable_if_t<TypeTraits::IsEnumerable<T>::value, std::string>
PrintToString(const T& value)
{
    std::ostringstream ostr;
    const size_t kMaxCount = 32; // The maximum number of elements to print
 
    ostr << '{';
    size_t count = 0;
 
    auto enumerator = const_cast<T&>(value).GetEnumerator();
    while (enumerator->MoveNext())
    {
        if (count > 0)
        {
            ostr << ',';
            if (count == kMaxCount) {  // Enough has been printed.
                ostr << " ...";
                break;
            }
        }
        ++count;
        ostr << ' ' << PrintToString(enumerator->get_Current());
    }
 
    if (count > 0)
        ostr << ' ';
 
    ostr << '}';
    return ostr.str();
}
 
template<typename T1, typename T2>
testing::AssertionResult EqFailure(const char* lhs_expr, const char* rhs_expr
    , T1& lhs
    , T2& rhs)
{
    return testing::internal::EqFailure(lhs_expr,
        rhs_expr,
        Details::PrintToString(lhs),
        Details::PrintToString(rhs),
        false);
}
template<typename T1, typename T2>
testing::AssertionResult NotEqFailure(const char* lhs_expr, const char* rhs_expr
    , T1& lhs
    , T2& rhs)
{
    return testing::AssertionFailure() 
        << "Expected: (" << lhs_expr << ") != (" << rhs_expr
        << "), actual: " << Details::PrintToString(lhs)
        << " vs " << Details::PrintToString(rhs); 
}
template<typename T1, typename T2>
testing::AssertionResult SameFailure(const char* lhs_expr, const char* rhs_expr
    , T1& lhs
    , T2& rhs)
{
    return testing::AssertionFailure() 
        << "Expected: (" << lhs_expr << ") same (" << rhs_expr
        << "), actual: " << Details::PrintToString(lhs)
        << " vs " << Details::PrintToString(rhs); 
}
template<typename T1, typename T2>
testing::AssertionResult NotSameFailure(const char* lhs_expr, const char* rhs_expr
    , T1& lhs
    , T2& rhs)
{
    return testing::AssertionFailure() 
        << "Expected: (" << lhs_expr << ") isn't same (" << rhs_expr
        << "), actual: " << Details::PrintToString(lhs)
        << " vs " << Details::PrintToString(rhs); 
}
 
namespace SharedPtrAsserts
{
 
template<typename T1, typename T2>
typename std::enable_if<!System::IsSmartPtr<typename T1::value_type>::value && !System::IsSmartPtr<typename T2::value_type>::value
    ,bool>::type
AreEqualContainer(const T1& lhs, const T2& rhs)
{
    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
template<typename T1, typename T2>
typename std::enable_if<System::IsSmartPtr<typename T1::value_type>::value && System::IsSmartPtr<typename T2::value_type>::value
    ,bool>::type
AreEqualContainer(const T1& lhs, const T2& rhs)
{
    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
        [](const typename T1::value_type &l, const typename T2::value_type &r)
        {
            return System::Object::Equals(l, r);
        }
    );
}
 
template<typename T1, typename T2>
typename std::enable_if<System::IsSmartPtr<typename T1::value_type>::value && System::IsSmartPtr<typename T2::value_type>::value
    ,bool>::type
AreEqualData(const T1& lhs, const T2& rhs)
{
    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
        [](const typename T1::value_type &l, const typename T2::value_type &r)
        {
            return System::Object::Equals(l, r);
        }
    );
}
template<typename T1, typename T2>
typename std::enable_if<!System::IsSmartPtr<typename T1::value_type>::value && !System::IsSmartPtr<typename T2::value_type>::value
    ,bool>::type
AreEqualData(const T1& lhs, const T2& rhs)
{
    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
template<typename T>
typename std::enable_if<!System::IsSmartPtr<typename T::value_type>::value
    ,bool>::type
AreEqualData(const T& lhs, const T& rhs)
{
    return lhs == rhs;
}
 
template<typename T>
bool AreEqualMapOfObjects(const T& lhs, const T& rhs)
{
    return lhs.size() == rhs.size() && std::all_of(lhs.begin(), lhs.end(), 
        [&rhs](const typename T::value_type value)
        {
            auto it = rhs.find(value.first);
            return it != rhs.end() && System::Object::Equals(value.second, it->second);
    });
}
 
template<typename T1, typename T2>
typename std::enable_if<TypeTraits::BothArrayOrList<typename T1::Pointee_, typename T2::Pointee_>::value
, testing::AssertionResult>::type
NotNullAreEqualImpl(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs, long long s)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
 
template<typename T1, typename T2>
typename std::enable_if<
    !TypeTraits::BothArrayOrList<typename T1::Pointee_, typename T2::Pointee_>::value &&
    TypeTraits::BothEnumerable<typename T1::Pointee_, typename T2::Pointee_>::value && 
    (!TypeTraits::has_data_method<typename T1::Pointee_>::value ||
    !TypeTraits::has_data_method<typename T2::Pointee_>::value), 
    testing::AssertionResult
>::type NotNullAreEqualImpl(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs, long long s)
{
    if (System::TestCompare::AreEqual(
            AsCast<System::Collections::Generic::IEnumerable<typename T1::Pointee_::ValueType>>(lhs),
            AsCast<System::Collections::Generic::IEnumerable<typename T2::Pointee_::ValueType>>(rhs)))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
 
 
template<typename K, typename V>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Dictionary<K, V>>& lhs
    , const SharedPtr<System::Collections::Generic::Dictionary<K, V>>& rhs)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Dictionary<K, SharedPtr<V>>>& lhs
    , const SharedPtr<System::Collections::Generic::Dictionary<K, SharedPtr<V>>>& rhs)
{
    if (AreEqualMapOfObjects(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::HashSet<T1>>& lhs
    , const SharedPtr<System::Collections::Generic::HashSet<T2>>& rhs)
{
    if (AreEqualContainer(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Queue<T1>>& lhs
    , const SharedPtr<System::Collections::Generic::Queue<T2>>& rhs)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Stack<T1>>& lhs
    , const SharedPtr<System::Collections::Generic::Stack<T2>>& rhs)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
}
template<typename K, typename V>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, V>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, V>>& rhs)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, SharedPtr<V>>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, SharedPtr<V>>>& rhs)
{
    if (AreEqualMapOfObjects(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedList<K, V>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedList<K, V>>& rhs)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedList<K, SharedPtr<V>>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedList<K, SharedPtr<V>>>& rhs)
{
    if (AreEqualMapOfObjects(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
inline testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::BitArray>& lhs
    , const SharedPtr<System::Collections::BitArray>& rhs)
{
    if (*lhs == *rhs)
    {
        return testing::AssertionSuccess();
    }
 
    return EqFailure(lhs_expr, 
                        rhs_expr, 
                        static_cast<System::Collections::Generic::IEnumerable<bool>&>(*lhs),
                        static_cast<System::Collections::Generic::IEnumerable<bool>&>(*rhs)
    );
}
inline testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Specialized::StringCollection>& lhs
    , const SharedPtr<System::Collections::Specialized::StringCollection>& rhs)
{
    if (AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T>
bool NotNullAreEqualHelper(const SharedPtr<System::Collections::Generic::ICollection<T>>& lhs
    , const SharedPtr<System::Collections::Generic::ICollection<T>>& rhs)
{
    static_assert(System::IsBoxable<T>::value, "Unsupported type for ICollection<T,_> compare");
 
    if (lhs->get_Count() != rhs->get_Count())
    {
        return false;
    }
 
    if (lhs->get_Count() == 0)
    {
        return true;
    }
 
    auto lhs_en = lhs->GetEnumerator();
    auto rhs_en = rhs->GetEnumerator();
 
    while (lhs_en->MoveNext() && rhs_en->MoveNext())
    {
        auto lhs_it = lhs_en->get_Current();
        auto rhs_it = rhs_en->get_Current();
        if (lhs_it != rhs_it)
        {
            return false;
        }
    }
                    
    return true;
}
template<typename T>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::ICollection<T>>& lhs
    , const SharedPtr<System::Collections::Generic::ICollection<T>>& rhs)
{
    if (NotNullAreEqualHelper(lhs, rhs))
    {
        return testing::AssertionSuccess();
    }
 
    return EqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreEqualImpl(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs, int32_t)
{
    if (lhs->Equals(rhs))
    {
        return ::testing::AssertionSuccess();
    }
 
    return EqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
}
 
inline testing::AssertionResult AreBoxedValuesEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<BoxedValueBase>& lhs
    , const SharedPtr<BoxedValueBase>& rhs)
{
    if (lhs->Equals(rhs))
    {
        return ::testing::AssertionSuccess();
    }
 
    const auto lt = lhs->GetTypeCode();
    const auto rt = rhs->GetTypeCode();
 
    if (lt == TypeCode::Double || rt == TypeCode::Double)
    {
        if (Convert::ToDouble(lhs) == Convert::ToDouble(rhs))
            return ::testing::AssertionSuccess();
    }
    else if (lt == TypeCode::Single || rt == TypeCode::Single)
    {
        if (Convert::ToSingle(lhs) == Convert::ToSingle(rhs))
            return ::testing::AssertionSuccess();
    }
    else if (lt == TypeCode::Decimal || rt == TypeCode::Decimal)
    {
        if (Convert::ToDecimal(lhs) == Convert::ToDecimal(rhs))
            return ::testing::AssertionSuccess();
    }
    return EqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
}
 
inline testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<Object>& lhs
    , const SharedPtr<Object>& rhs)
{
    if (ObjectExt::IsBoxedValue(lhs) && ObjectExt::IsBoxedValue(rhs))
    {
        return AreBoxedValuesEqual(lhs_expr, rhs_expr, AsCast<BoxedValueBase>(lhs), AsCast<BoxedValueBase>(rhs));
    }
 
    return NotNullAreEqualImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<T1>& lhs
    , const SharedPtr<T2>& rhs)
{
    return NotNullAreEqualImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
 
template<typename T1, typename T2>
testing::AssertionResult AreEqual(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs)
{
    if (static_cast<System::Object*>(lhs.GetObjectOrNull()) == static_cast<System::Object*>(rhs.GetObjectOrNull())) 
    {
        return testing::AssertionSuccess();
    }
 
    if (!lhs || !rhs)
    {
        if (!lhs)
        {
            return testing::internal::EqFailure(lhs_expr, rhs_expr,
                "nullptr",
                Details::PrintToString(*rhs),
                false);
        }
        return testing::internal::EqFailure(lhs_expr, rhs_expr,
            Details::PrintToString(*lhs),
            "nullptr",
            false);
    }
 
    return NotNullAreEqual(lhs_expr, rhs_expr, lhs, rhs);
}
 
// AreNotEqual for SharedPtr ==================================
 
template<typename T1, typename T2>
typename std::enable_if<TypeTraits::BothArrayOrList<typename T1::Pointee_, typename T2::Pointee_>::value
, testing::AssertionResult>::type
NotNullAreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs, long long s)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
 
template<typename T1, typename T2>
typename std::enable_if<
    !TypeTraits::BothArrayOrList<typename T1::Pointee_, typename T2::Pointee_>::value &&
    TypeTraits::BothEnumerable<typename T1::Pointee_, typename T2::Pointee_>::value && 
    (!TypeTraits::has_data_method<typename T1::Pointee_>::value ||
    !TypeTraits::has_data_method<typename T2::Pointee_>::value), 
    testing::AssertionResult
>::type NotNullAreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs, long long s)
{
    if (!System::TestCompare::AreEqual(
            AsCast<System::Collections::Generic::IEnumerable<typename T1::Pointee_::ValueType>>(lhs),
            AsCast<System::Collections::Generic::IEnumerable<typename T2::Pointee_::ValueType>>(rhs)
    ))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
 
template<typename K, typename V>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Dictionary<K, V>>& lhs
    , const SharedPtr<System::Collections::Generic::Dictionary<K, V>>& rhs)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Dictionary<K, SharedPtr<V>>>& lhs
    , const SharedPtr<System::Collections::Generic::Dictionary<K, SharedPtr<V>>>& rhs)
{
    if (!AreEqualMapOfObjects(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::HashSet<T1>>& lhs
    , const SharedPtr<System::Collections::Generic::HashSet<T2>>& rhs)
{
    if (!AreEqualContainer(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Queue<T1>>& lhs
    , const SharedPtr<System::Collections::Generic::Queue<T2>>& rhs)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::Stack<T1>>& lhs
    , const SharedPtr<System::Collections::Generic::Stack<T2>>& rhs)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, V>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, V>>& rhs)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, SharedPtr<V>>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedDictionary<K, SharedPtr<V>>>& rhs)
{
    if (!AreEqualMapOfObjects(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedList<K, V>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedList<K, V>>& rhs)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename K, typename V>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::SortedList<K, SharedPtr<V>>>& lhs
    , const SharedPtr<System::Collections::Generic::SortedList<K, SharedPtr<V>>>& rhs)
{
    if (!AreEqualMapOfObjects(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
inline testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::BitArray>& lhs
    , const SharedPtr<System::Collections::BitArray>& rhs)
{
    if (*lhs != *rhs)
    {
        return testing::AssertionSuccess();
    }
 
    return NotEqFailure(lhs_expr,
                        rhs_expr,
                        static_cast<System::Collections::Generic::ICollection<bool>&>(*lhs),
                        static_cast<System::Collections::Generic::ICollection<bool>&>(*rhs)
    );
}
inline testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Specialized::StringCollection>& lhs
    , const SharedPtr<System::Collections::Specialized::StringCollection>& rhs)
{
    if (!AreEqualData(lhs->data(), rhs->data()))
    {
        return testing::AssertionSuccess();
    }
    return NotEqFailure(lhs_expr, rhs_expr, lhs->data(), rhs->data());
}
template<typename T>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<System::Collections::Generic::ICollection<T>>& lhs
    , const SharedPtr<System::Collections::Generic::ICollection<T>>& rhs)
{
    if (!NotNullAreEqualHelper(lhs, rhs))
    {
        return testing::AssertionSuccess();
    }
 
    return NotEqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs, int32_t)
{
    if (!lhs->Equals(rhs))
    {
        return ::testing::AssertionSuccess();
    }
 
    return NotEqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
}
template<typename T1, typename T2>
testing::AssertionResult NotNullAreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const SharedPtr<T1>& lhs
    , const SharedPtr<T2>& rhs)
{
    return NotNullAreNotEqualImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
 
template<typename T1, typename T2>
testing::AssertionResult AreNotEqual(const char* lhs_expr, const char* rhs_expr
    , const T1& lhs, const T2& rhs)
{
    // xor
    if (!lhs != !rhs)
    {
        // One of operands is nullptr
        return testing::AssertionSuccess();
    }
 
    // both are nullptr
    if (!lhs && !rhs)
    {
        return NotEqFailure(lhs_expr, rhs_expr, "nullptr", "nullptr");
    }
 
    if (static_cast<System::Object*>(lhs.GetObjectOrNull()) == static_cast<System::Object*>(rhs.GetObjectOrNull())) 
    {
        return NotEqFailure(lhs_expr, rhs_expr, *lhs, *rhs);
    }
 
    return NotNullAreNotEqual(lhs_expr, rhs_expr, lhs, rhs);
}
 
} 
} 
 
template<typename T1, typename T2>
typename std::enable_if<std::numeric_limits<T1>::has_quiet_NaN && std::numeric_limits<T2>::has_quiet_NaN, bool>::type
    AreFPNaN(T1 lhs, T2 rhs) { return (std::isnan(lhs) && std::isnan(rhs)); }
template<typename T1, typename T2>
typename std::enable_if<!std::numeric_limits<T1>::has_quiet_NaN || !std::numeric_limits<T2>::has_quiet_NaN, bool>::type
    AreFPNaN(T1 lhs, T2 rhs) { return false; }
 
 
// AreEqual ===========================================================
template<typename T1, typename T2>
testing::AssertionResult AreEqual(const char* lhs_expr, const char* rhs_expr, T1&& lhs, T2&& rhs);
 
// FP and arithmetic types
template <typename T1, typename T2>
typename std::enable_if<TypeTraits::AreFPandArithmetic<T1, T2>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T1 lhs
        , const T2 rhs
        , long long s)
{
    return AreFPNaN(lhs, rhs) ? testing::AssertionSuccess() :
        testing::internal::CmpHelperFloatingPointEQ<typename TypeTraits::LargestFPType<T1, T2>::type>(lhs_expr, rhs_expr, 
        static_cast<typename TypeTraits::LargestFPType<T1, T2>::type>(lhs), static_cast<typename TypeTraits::LargestFPType<T1, T2>::type>(rhs));
}
template <typename T1, typename T2>
typename std::enable_if<TypeTraits::AnyOfDecimal<T1, T2>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    return testing::internal::
        EqHelper::Compare<System::Decimal, System::Decimal>
        (lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<!IsSmartPtr<T>::value && detail::has_method_equals<T>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T& lhs
        , const T& rhs
        , long long s)
{
    if (lhs.Equals(rhs)) {
        return testing::AssertionSuccess();
    }
 
    return Details::EqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<!IsSmartPtr<T>::value && detail::has_method_equals<T>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T& lhs
        , const T& rhs
        , long long s)
{
    ASPOSE_UNUSED(s);
    if (lhs.Equals(rhs)) {
        return testing::AssertionSuccess();
    }
 
    return Details::EqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<!IsSmartPtr<T>::value && std::is_class<T>::value && !detail::has_method_equals<T>::value && detail::has_operator_equal<T>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T& lhs
        , const T& rhs
        , long long s)
{
    if (lhs == rhs) {
        return testing::AssertionSuccess();
    }
 
    return Details::EqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<IsBoxable<T>::value && ! IsStringByteSequence<T, char16_t>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T lhs
        , const System::SharedPtr<Object>& rhs
        , long long s)
{
    return AreEqual(lhs_expr, rhs_expr, ObjectExt::Box<T>(lhs), rhs);
}
template <typename T>
typename std::enable_if<IsBoxable<T>::value && ! IsStringByteSequence<T, char16_t>::value
    , testing::AssertionResult>::type
    AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const System::SharedPtr<Object>& lhs
        , T rhs
        , long long s)
{
    return AreEqual(lhs_expr, rhs_expr, lhs, ObjectExt::Box<T>(rhs));
}
inline testing::AssertionResult AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const char16_t* lhs
        , const System::SharedPtr<Object>& rhs
        , long long s)
{
    ASPOSE_UNUSED(s);
    return AreEqual(lhs_expr, rhs_expr, System::String(lhs), System::ObjectExt::Unbox<System::String>(rhs));
}
inline testing::AssertionResult AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const System::SharedPtr<Object>& lhs
        , const char16_t* rhs
        , long long s)
{
    ASPOSE_UNUSED(s);
    return AreEqual(lhs_expr, rhs_expr, System::ObjectExt::Unbox<System::String>(lhs), System::String(rhs));
}
template <typename T>
testing::AssertionResult AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T lhs
        , std::nullptr_t
        , long long s)
{
    if (System::TestTools::IsNull(lhs))
    {
        return testing::AssertionSuccess();
    }
 
    return testing::internal::EqFailure(lhs_expr, rhs_expr,
        Details::PrintToString(lhs),
        "nullptr",
        false);
}
template <typename T>
testing::AssertionResult AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , std::nullptr_t
        , T rhs
        , long long s)
{
    if (System::TestTools::IsNull(rhs))
    {
        return testing::AssertionSuccess();
    }
 
    return testing::internal::EqFailure(lhs_expr, rhs_expr,
        "nullptr",
        Details::PrintToString(rhs),
        false);
}
template<typename T1, typename T2>
typename
    std::enable_if<
        IsSmartPtr<T1>::value && IsSmartPtr<T2>::value &&
        (
            !std::is_base_of<System::IO::Stream, typename T1::Pointee_>::value ||
            !std::is_base_of<System::IO::Stream, typename T2::Pointee_>::value
        ),
        testing::AssertionResult
    >::type
AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    return Details::SharedPtrAsserts::AreEqual(lhs_expr, rhs_expr, lhs, rhs);
}
 
template<typename T1, typename T2>
typename
    std::enable_if<
        IsSmartPtr<T1>::value && IsSmartPtr<T2>::value &&
        std::is_base_of<System::IO::Stream, typename T1::Pointee_>::value &&
        std::is_base_of<System::IO::Stream, typename T2::Pointee_>::value,
        testing::AssertionResult
    >::type
AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    if (static_cast<System::Object*>(lhs.GetObjectOrNull()) == static_cast<System::Object*>(rhs.GetObjectOrNull()))
    {
        return testing::AssertionSuccess();
    }
 
    if (!lhs || !rhs)
    {
        if (!lhs)
        {
            return testing::internal::EqFailure(lhs_expr, rhs_expr,
                "nullptr",
                Details::PrintToString(*rhs),
                false);
        }
        return testing::internal::EqFailure(lhs_expr, rhs_expr,
            Details::PrintToString(*lhs),
            "nullptr",
            false);
    }
 
    int32_t b1, b2;
 
    lhs->set_Position(0);
    rhs->set_Position(0);
 
    do
    {
        b1 = lhs->ReadByte();
        b2 = rhs->ReadByte();
 
        if (b1 != b2)
        {
            return testing::internal::EqFailure(lhs_expr, rhs_expr,
                Details::PrintToString(lhs),
                Details::PrintToString(rhs),
                false);
        }
 
    } while (b1 != -1 && b2 != -1);
 
    return testing::AssertionSuccess();
}
 
template <typename T1, typename T2>
typename std::enable_if<!std::is_null_pointer<T1>::value && !IsNullable<T1>::value, testing::AssertionResult>::type
AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T1 lhs
        , const Nullable<T2>& rhs
        , long long s)
{
    return rhs.IsNull() ? AreEqual(lhs_expr, rhs_expr, lhs, nullptr)
                        : AreEqual(lhs_expr, rhs_expr, lhs, rhs.get_Value());
}
template <typename T1, typename T2>
typename std::enable_if<!std::is_null_pointer<T2>::value && !IsNullable<T2>::value, testing::AssertionResult>::type
AreEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const Nullable<T1>& lhs
        , T2 rhs
        , long long s)
{
    return lhs.IsNull() ? AreEqual(lhs_expr, rhs_expr, nullptr, rhs)
                        : AreEqual(lhs_expr, rhs_expr, lhs.get_Value(), rhs);
}
 
template<typename T1, typename T2>
testing::AssertionResult AreEqualImpl(const char* lhs_expr, const char* rhs_expr, T1 lhs, T2 rhs, int)
{
    return ::testing::internal::EqHelper::Compare(lhs_expr, rhs_expr, lhs, rhs);
}
template<typename T1, typename T2>
testing::AssertionResult AreEqual(const char* lhs_expr, const char* rhs_expr, T1&& lhs, T2&& rhs)
{
    return AreEqualImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
 
// AreNotEqual ========================================================
template<typename T1, typename T2>
testing::AssertionResult AreNotEqual(const char* lhs_expr, const char* rhs_expr, T1&& lhs, T2&& rhs);
 
template <typename T1, typename T2>
typename std::enable_if<TypeTraits::AnyOfDecimal<T1, T2>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    if (System::Decimal(lhs) != System::Decimal(rhs))
    {
        return testing::AssertionSuccess();
    }
 
    return Details::NotEqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<!IsSmartPtr<T>::value && detail::has_method_equals<T>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T& lhs
        , const T& rhs
        , long long s)
{
    if (! lhs.Equals(rhs)) {
        return testing::AssertionSuccess();
    }
 
    return Details::NotEqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<!IsSmartPtr<T>::value && detail::has_method_equals<T>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T& lhs
        , const T& rhs
        , long long s)
{
    if (!lhs.Equals(rhs)) {
        return testing::AssertionSuccess();
    }
 
    return Details::NotEqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<!IsSmartPtr<T>::value && std::is_class<T>::value && !detail::has_method_equals<T>::value && detail::has_operator_equal<T>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T& lhs
        , const T& rhs
        , long long s)
{
    if (lhs != rhs) {
        return testing::AssertionSuccess();
    }
 
    return Details::EqFailure(lhs_expr, rhs_expr, lhs, rhs);
}
template <typename T>
typename std::enable_if<IsBoxable<T>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T lhs
        , const System::SharedPtr<Object>& rhs
        , long long s)
{
    return AreNotEqual(lhs_expr, rhs_expr, lhs, System::ObjectExt::Unbox<T>(rhs));
}
template <typename T>
typename std::enable_if<IsBoxable<T>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const System::SharedPtr<Object>& lhs
        , T rhs
        , long long s)
{
    return AreNotEqual(lhs_expr, rhs_expr, System::ObjectExt::Unbox<T>(lhs), rhs);
}
template <typename T>
testing::AssertionResult AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , T lhs
        , std::nullptr_t
        , long long s)
{
    if (!System::TestTools::IsNull(lhs))
    {
        return testing::AssertionSuccess();
    }
 
    return Details::NotEqFailure(lhs_expr, rhs_expr, lhs, "nullptr");
}
template <typename T>
testing::AssertionResult AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , std::nullptr_t
        , T rhs
        , long long s)
{
    if (!System::TestTools::IsNull(rhs))
    {
        return testing::AssertionSuccess();
    }
 
    return Details::NotEqFailure(lhs_expr, rhs_expr, "nullptr", rhs);
}
template<typename T1, typename T2>
typename std::enable_if<IsSmartPtr<T1>::value && IsSmartPtr<T2>::value
    , testing::AssertionResult>::type
    AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    return Details::SharedPtrAsserts::AreNotEqual(lhs_expr, rhs_expr, lhs, rhs);
}
template<typename T1, typename T2>
testing::AssertionResult AreNotEqualImpl(const char* lhs_expr, const char* rhs_expr, T1 lhs, T2 rhs, int)
{
    return ::testing::internal::CmpHelperNE(lhs_expr, rhs_expr, lhs , rhs);
}
template<typename T1, typename T2>
testing::AssertionResult AreNotEqual(const char* lhs_expr, const char* rhs_expr, T1&& lhs, T2&& rhs)
{
    return AreNotEqualImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
 
// AreSame ============================================================
template<typename T1, typename T2>
testing::AssertionResult AreSame(const char* lhs_expr, const char* rhs_expr, const T1& lhs, const T2& rhs);
 
template<typename T1, typename T2>
typename std::enable_if<IsSmartPtr<T1>::value && IsSmartPtr<T2>::value
    , testing::AssertionResult>::type
    AreSameImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    // xor
    if (!lhs != !rhs)
    {
        if (!lhs)
        {
            auto rhs_addr = reinterpret_cast<std::ptrdiff_t>(rhs.GetObjectOrNull());
            return Details::SameFailure(lhs_expr, rhs_expr, "nullptr", rhs_addr);
        }
        auto lhs_addr = reinterpret_cast<std::ptrdiff_t>(lhs.GetObjectOrNull());
        return Details::SameFailure(lhs_expr, rhs_expr, lhs_addr, "nullptr");
    }
 
    // both are nullptr
    if (!lhs && !rhs)
    {
        return testing::AssertionSuccess();
    }
 
    if (static_cast<System::Object*>(lhs.GetObjectOrNull()) == static_cast<System::Object*>(rhs.GetObjectOrNull()))
    {
        return testing::AssertionSuccess();
    }
 
    auto rhs_addr = reinterpret_cast<std::ptrdiff_t>(rhs.GetObjectOrNull());
    auto lhs_addr = reinterpret_cast<std::ptrdiff_t>(lhs.GetObjectOrNull());
    return Details::SameFailure(lhs_expr, rhs_expr, lhs_addr, rhs_addr);
}
template<typename T1, typename T2>
typename std::enable_if<IsExceptionWrapper<T1>::value && IsExceptionWrapper<T2>::value
    , testing::AssertionResult>::type
    AreSameImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    if (lhs == rhs)
        return testing::AssertionSuccess();
    
    auto rhs_addr = reinterpret_cast<std::ptrdiff_t>(&rhs);
    auto lhs_addr = reinterpret_cast<std::ptrdiff_t>(&lhs);
    return Details::SameFailure(lhs_expr, rhs_expr, lhs_addr, rhs_addr);
}
template<typename T1, typename T2>
testing::AssertionResult AreSameImpl(const char* lhs_expr, const char* rhs_expr, const T1& lhs, const T2& rhs, int)
{
    if (&lhs == &rhs)
    {
        return testing::AssertionSuccess();
    }
 
    std::ptrdiff_t lhs_addr = reinterpret_cast<std::ptrdiff_t>(&lhs);
    std::ptrdiff_t rhs_addr = reinterpret_cast<std::ptrdiff_t>(&rhs);
    return Details::SameFailure(lhs_expr, rhs_expr, lhs_addr, rhs_addr);
}
 
template<typename T1, typename T2>
testing::AssertionResult AreSame(const char* lhs_expr, const char* rhs_expr, const T1& lhs, const T2& rhs)
{
    return AreSameImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
 
// AreNotSame =========================================================
template<typename T1, typename T2>
testing::AssertionResult AreNotSame(const char* lhs_expr, const char* rhs_expr, const T1& lhs, const T2& rhs);
 
template<typename T1, typename T2>
typename std::enable_if<IsSmartPtr<T1>::value && IsSmartPtr<T2>::value
    , testing::AssertionResult>::type
    AreNotSameImpl(const char* lhs_expr, const char* rhs_expr
        , const T1& lhs
        , const T2& rhs
        , long long s)
{
    // xor
    if (!lhs != !rhs)
    {
        return testing::AssertionSuccess();
    }
 
    // both are nullptr
    if (!lhs && !rhs)
    {
        return Details::NotSameFailure(lhs_expr, rhs_expr, "nullptr", "nullptr");
    }
 
    if (static_cast<System::Object*>(lhs.GetObjectOrNull()) != static_cast<System::Object*>(rhs.GetObjectOrNull()))
    {
        return testing::AssertionSuccess();
    }
 
    auto rhs_addr = reinterpret_cast<std::ptrdiff_t>(rhs.GetObjectOrNull());
    auto lhs_addr = reinterpret_cast<std::ptrdiff_t>(lhs.GetObjectOrNull());
    return Details::NotSameFailure(lhs_expr, rhs_expr, lhs_addr, rhs_addr);
}
template<typename T1, typename T2>
testing::AssertionResult AreNotSameImpl(const char* lhs_expr, const char* rhs_expr, const T1& lhs, const T2& rhs, int)
{
    if (&lhs != &rhs)
    {
        return testing::AssertionSuccess();
    }
 
    std::ptrdiff_t lhs_addr = reinterpret_cast<std::ptrdiff_t>(&lhs);
    std::ptrdiff_t rhs_addr = reinterpret_cast<std::ptrdiff_t>(&rhs);
    return Details::NotSameFailure(lhs_expr, rhs_expr, lhs_addr, rhs_addr);
}
 
template<typename T1, typename T2>
testing::AssertionResult AreNotSame(const char* lhs_expr, const char* rhs_expr, const T1& lhs, const T2& rhs)
{
    return AreNotSameImpl(lhs_expr, rhs_expr, lhs, rhs, 1LL);
}
 
template<typename T>
testing::AssertionResult IsInstanceOf(const char* lhs_expr, const char* rhs_expr, const TypeInfo& typeInfo, const T& obj)
{
    if (obj->Is(typeInfo))
    {
        return ::testing::AssertionSuccess();
    }
            
    return testing::AssertionFailure()
        << "Expected: " << rhs_expr << " is " << lhs_expr
        << ", actual: " << obj->GetType().ToString().ToUtf8String()
        << " vs " << typeInfo.ToString().ToUtf8String();
}
 
} // namespace TestPredicates
} // namespace System
 
#define ASPOSE_ASSERT_EQ(val1, val2) \
  ASSERT_PRED_FORMAT2(System::TestPredicates::AreEqual, val1, val2)
 
#define ASPOSE_EXPECT_EQ(val1, val2) \
  EXPECT_PRED_FORMAT2(System::TestPredicates::AreEqual, val1, val2)
 
#define ASPOSE_ASSERT_NE(val1, val2) \
  ASSERT_PRED_FORMAT2(System::TestPredicates::AreNotEqual, val1, val2)
 
#define ASPOSE_EXPECT_NE(val1, val2) \
  EXPECT_PRED_FORMAT2(System::TestPredicates::AreNotEqual, val1, val2)
 
#define ASPOSE_ASSERT_SAME(val1, val2) \
  ASSERT_PRED_FORMAT2(System::TestPredicates::AreSame, val1, val2)
 
#define ASPOSE_EXPECT_SAME(val1, val2) \
  EXPECT_PRED_FORMAT2(System::TestPredicates::AreSame, val1, val2)
 
#define ASPOSE_ASSERT_NS(val1, val2) \
  ASSERT_PRED_FORMAT2(System::TestPredicates::AreNotSame, val1, val2)
 
#define ASPOSE_EXPECT_NS(val1, val2) \
  EXPECT_PRED_FORMAT2(System::TestPredicates::AreNotSame, val1, val2)
 
#define ASPOSE_ASSERT_ISINSTANCEOF(val1, val2) \
  ASSERT_PRED_FORMAT2(System::TestPredicates::IsInstanceOf, val1, val2)
 
#define ASPOSE_EXPECT_ISINSTANCEOF(val1, val2) \
  EXPECT_PRED_FORMAT2(System::TestPredicates::IsInstanceOf, val1, val2)
 
#define ASPOSE_GTEST_TEST_THROW_(statement, expected_exception, exception_ref, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
    bool gtest_caught_expected = false; \
    try { \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
    } \
    catch (expected_exception const& e) { \
      gtest_caught_expected = true; \
      static_assert(std::is_base_of<std::remove_pointer<decltype(exception_ref)>::type, expected_exception>::value, "Should be base class of expected exception"); \
      *exception_ref = e; \
    } \
    catch (...) { \
      gtest_msg.value = \
          "Expected: " #statement " throws an exception of type " \
          #expected_exception ".\n  Actual: it throws a different type."; \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
    } \
    if (!gtest_caught_expected) { \
      gtest_msg.value = \
          "Expected: " #statement " throws an exception of type " \
          #expected_exception ".\n  Actual: it throws nothing."; \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
    } \
  } else \
    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
      fail(gtest_msg.value)
 
#define ASPOSE_ASSERT_THROW(statement, expected_exception, exception_ref) \
    ASPOSE_GTEST_TEST_THROW_(statement, expected_exception, exception_ref, GTEST_FATAL_FAILURE_);
 
#define ASPOSE_ASSERT_THROW_EXCEPTION_TYPE_(statement, expected_exception_type, fail) \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
    bool gtest_caught_expected = false; \
    try { \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
    } \
    catch (const System::Exception& e) { \
      gtest_caught_expected = true; \
      if(e.Get()->GetType() != expected_exception_type)\
      { \
      gtest_msg.value = \
          "Actual: " #statement " throws a different type."; \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
      } \
    } \
    catch (...) { \
      gtest_msg.value = \
          "Actual: " #statement " throws a unexpected exception type."; \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
    } \
    if (!gtest_caught_expected) { \
      gtest_msg.value = \
          "Actual: " #statement " throws nothing."; \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
    } \
  } else \
    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
      fail(gtest_msg.value)
 
#define ASPOSE_ASSERT_THROW_EXCEPTION_TYPE(statement, exceptionType) \
    ASPOSE_ASSERT_THROW_EXCEPTION_TYPE_(statement, exceptionType, GTEST_FATAL_FAILURE_)