CPPUNIT_ASSERT_EQUAL on std collections - c++

Question

I know I can specialize assertion_traits on std::vector<>:
namespace CPPUNIT_NS
{
template <class T> struct assertion_traits<std::vector<T>>
{
inline static bool equal(const std::vector<T>& left, const std::vector<T>& right)
{
return std::equal(left.begin(), left.end(), right.begin(), assertion_traits<std::vector<T>>::equal);
}
inline static string toString(const std::vector<T>& vector)
// etc...
But if I want to CPPUNIT_ASSERT_EQUAL on unordered_set, I have to write another assertion_traits. How can I write one assertion_traits that works on all things with iterators?
I'm guessing I need something like Boosts's range concepts?

Answer 1

You can make use of alias template that would sfinae out types without containing iterator type passed to your specialization e.g.:
#include <vector>
#include <array>
template <class>
struct without_iterator { };
template <class T>
struct X {
static constexpr bool value = false;
};
template <class T, class...>
using typer = T;
template <class T>
struct X<typer<T, typename T::iterator>> {
static constexpr bool value = true;
};
int main() {
static_assert(X<std::vector<int>>::value, "!");
static_assert(X<std::array<int, 4>>::value, "!");
static_assert(!X<without_iterator<int>>::value, "!");
static_assert(!X<int>::value, "!");
}
where X is your CPPUNIT_NS::assertion_traits
[live demo]
To apply it to your solution:
template <class T, class...>
using typer = T;
namespace CPPUNIT_NS
{
template <class T> struct assertion_traits<typer<T, typename T::iterator>>
{
inline static bool equal(const T& left, const T& right)
{
return std::equal(left.begin(), left.end(), right.begin(), assertion_traits<decltype(*(left.begin()))>::equal);
}
inline static string toString(const T& vector)
// etc...
If you'd like you could also test for begin end existance to make sure interface of your T is as expected. You could even test if T comes from std namespace if you'd like (at least in some limited extend).
Edit:
The safer approach would be to stick to:
template <template <class...> class V, class... Ts>
struct X<typer<V<Ts...>, typename V<Ts...>::iterator>> {
static constexpr bool value = true;
};
even though it can't be applied to std::array as using struct X<typer<T, typename T::iterator>> might not be seen by the compiler as specialization of an X template but the redefinition of X (example)...

Answer 2

What about
template <template <typename ...> class C, typename ... T>
struct assertion_traits<C<T...>>
{
inline static bool equal(C<T...> const & left, C<T...> const & right)
{
return std::equal(left.begin(), left.end(), right.begin(),
assertion_traits<decltype(*(left.begin()))>::equal);
}
};
?
Doesn't work with "all things with iterators" (by example: doesn't work with std::array because there is a template argument that isn't a type) but should intercept a lot of they.
A big problem is that can intercept also containers without iterators; I suggest you to follow the example from W.C.; a solution based on typer can intercept std::array and avoid false positives.
Anyway, a full working example
#include <vector>
#include <algorithm>
template <typename T>
struct assertion_traits
{
inline static bool equal (T const & left, T const & right)
{ return left == right; }
};
template <template <typename ...> class C, typename ... T>
struct assertion_traits<C<T...>>
{
inline static bool equal(C<T...> const & left, C<T...> const & right)
{
return std::equal(left.begin(), left.end(), right.begin(),
assertion_traits<decltype(*(left.begin()))>::equal);
}
};
int main ()
{
std::vector<int> v1;
assertion_traits<std::vector<int>>::equal(v1, v1);
}