#ifndef TEST_CONTAINER_COMPARISONS
#define TEST_CONTAINER_COMPARISONS
+#include <functional>
#include <set>
#include "test_comparisons.h"
}
// Implementation detail of `test_ordered_map_container_spaceship`
-template <template <typename...> typename Container, typename Key, typename Val, typename Order>
-constexpr void test_ordered_map_container_spaceship_with_type() {
+template <template <typename...> typename Container, typename Key, typename Val, typename Order, typename Compare>
+constexpr void test_ordered_map_container_spaceship_with_type(Compare comp) {
// Empty containers
{
- Container<Key, Val> l1;
- Container<Key, Val> l2;
+ Container<Key, Val, Compare> l1{{}, comp};
+ Container<Key, Val, Compare> l2{{}, comp};
assert(testOrder(l1, l2, Order::equivalent));
}
// Identical contents
{
- Container<Key, Val> l1{{1, 1}, {2, 1}};
- Container<Key, Val> l2{{1, 1}, {2, 1}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 1}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 1}}, comp};
assert(testOrder(l1, l2, Order::equivalent));
}
// Less, due to contained values
{
- Container<Key, Val> l1{{1, 1}, {2, 1}};
- Container<Key, Val> l2{{1, 1}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 1}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::less));
}
// Greater, due to contained values
{
- Container<Key, Val> l1{{1, 1}, {2, 3}};
- Container<Key, Val> l2{{1, 1}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 3}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::greater));
}
// Shorter list
{
- Container<Key, Val> l1{{1, 1}};
- Container<Key, Val> l2{{1, 1}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::less));
}
// Longer list
{
- Container<Key, Val> l1{{1, 2}, {2, 2}};
- Container<Key, Val> l2{{1, 1}};
+ Container<Key, Val, Compare> l1{{{1, 2}, {2, 2}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}}, comp};
assert(testOrder(l1, l2, Order::greater));
}
// Unordered
if constexpr (std::is_same_v<Val, PartialOrder>) {
- Container<Key, Val> l1{{1, 1}, {2, std::numeric_limits<int>::min()}};
- Container<Key, Val> l2{{1, 1}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, std::numeric_limits<int>::min()}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::unordered));
}
// Identical contents
{
- Container<Key, Val> l1{{1, 1}, {2, 1}, {2, 2}};
- Container<Key, Val> l2{{1, 1}, {2, 1}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 1}, {2, 2}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 1}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::equivalent));
- Container<Key, Val> l3{{1, 1}, {2, 1}, {2, 2}};
- Container<Key, Val> l4{{2, 1}, {2, 2}, {1, 1}};
+
+ Container<Key, Val, Compare> l3{{{1, 1}, {2, 1}, {2, 2}}, comp};
+ Container<Key, Val, Compare> l4{{{2, 1}, {2, 2}, {1, 1}}, comp};
assert(testOrder(l3, l4, Order::equivalent));
}
// Less, due to contained values
{
- Container<Key, Val> l1{{1, 1}, {2, 1}, {2, 1}};
- Container<Key, Val> l2{{1, 1}, {2, 2}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 1}, {2, 1}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::less));
- Container<Key, Val> l3{{1, 1}, {2, 1}, {2, 1}};
- Container<Key, Val> l4{{2, 2}, {2, 2}, {1, 1}};
+
+ Container<Key, Val, Compare> l3{{{1, 1}, {2, 1}, {2, 1}}, comp};
+ Container<Key, Val, Compare> l4{{{2, 2}, {2, 2}, {1, 1}}, comp};
assert(testOrder(l3, l4, Order::less));
}
// Greater, due to contained values
{
- Container<Key, Val> l1{{1, 1}, {2, 3}, {2, 3}};
- Container<Key, Val> l2{{1, 1}, {2, 2}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 3}, {2, 3}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::greater));
- Container<Key, Val> l3{{1, 1}, {2, 3}, {2, 3}};
- Container<Key, Val> l4{{2, 2}, {2, 2}, {1, 1}};
+
+ Container<Key, Val, Compare> l3{{{1, 1}, {2, 3}, {2, 3}}, comp};
+ Container<Key, Val, Compare> l4{{{2, 2}, {2, 2}, {1, 1}}, comp};
assert(testOrder(l3, l4, Order::greater));
}
// Shorter list
{
- Container<Key, Val> l1{{1, 1}, {2, 2}};
- Container<Key, Val> l2{{1, 1}, {2, 2}, {2, 2}, {3, 1}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, 2}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}, {2, 2}, {3, 1}}, comp};
assert(testOrder(l1, l2, Order::less));
- Container<Key, Val> l3{{1, 1}, {2, 2}};
- Container<Key, Val> l4{{3, 1}, {2, 2}, {2, 2}, {1, 1}};
+
+ Container<Key, Val, Compare> l3{{{1, 1}, {2, 2}}, comp};
+ Container<Key, Val, Compare> l4{{{3, 1}, {2, 2}, {2, 2}, {1, 1}}, comp};
assert(testOrder(l3, l4, Order::less));
}
// Longer list
{
- Container<Key, Val> l1{{1, 2}, {2, 2}, {2, 2}, {3, 1}};
- Container<Key, Val> l2{{1, 1}, {2, 2}};
+ Container<Key, Val, Compare> l1{{{1, 2}, {2, 2}, {2, 2}, {3, 1}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}}, comp};
assert(testOrder(l1, l2, Order::greater));
- Container<Key, Val> l3{{1, 2}, {2, 2}, {2, 2}, {3, 1}};
- Container<Key, Val> l4{{2, 2}, {1, 1}};
+
+ Container<Key, Val, Compare> l3{{{1, 2}, {2, 2}, {2, 2}, {3, 1}}, comp};
+ Container<Key, Val, Compare> l4{{{2, 2}, {1, 1}}, comp};
assert(testOrder(l3, l4, Order::greater));
}
// Unordered
if constexpr (std::is_same_v<Val, PartialOrder>) {
- Container<Key, Val> l1{{1, 1}, {2, std::numeric_limits<int>::min()}, {2, 3}};
- Container<Key, Val> l2{{1, 1}, {2, 2}, {2, 3}};
+ Container<Key, Val, Compare> l1{{{1, 1}, {2, std::numeric_limits<int>::min()}, {2, 3}}, comp};
+ Container<Key, Val, Compare> l2{{{1, 1}, {2, 2}, {2, 3}}, comp};
assert(testOrder(l1, l2, Order::unordered));
- Container<Key, Val> l3{{1, 1}, {2, std::numeric_limits<int>::min()}, {2, 3}};
- Container<Key, Val> l4{{2, 3}, {2, 2}, {1, 1}};
+
+ Container<Key, Val, Compare> l3{{{1, 1}, {2, std::numeric_limits<int>::min()}, {2, 3}}, comp};
+ Container<Key, Val, Compare> l4{{{2, 3}, {2, 2}, {1, 1}}, comp};
assert(testOrder(l3, l4, Order::unordered));
}
}
// Tests the `operator<=>` on ordered map containers
template <template <typename...> typename Container>
constexpr bool test_ordered_map_container_spaceship() {
+ // Thanks to SFINAE, the following is not a compiler error but returns `false`
+ struct NonComparable {};
+ static_assert(!std::three_way_comparable<Container<int, NonComparable>>);
+
// The container should fulfill `std::three_way_comparable`
static_assert(std::three_way_comparable<Container<int, int>>);
// Test different comparison categories
- test_ordered_map_container_spaceship_with_type<Container, int, int, std::strong_ordering>();
- test_ordered_map_container_spaceship_with_type<Container, int, StrongOrder, std::strong_ordering>();
- test_ordered_map_container_spaceship_with_type<Container, int, WeakOrder, std::weak_ordering>();
- test_ordered_map_container_spaceship_with_type<Container, int, PartialOrder, std::partial_ordering>();
+ test_ordered_map_container_spaceship_with_type<Container, int, int, std::strong_ordering>(std::less{});
+ test_ordered_map_container_spaceship_with_type<Container, int, int, std::strong_ordering>(std::greater{});
+ test_ordered_map_container_spaceship_with_type<Container, int, StrongOrder, std::strong_ordering>(std::less{});
+ test_ordered_map_container_spaceship_with_type<Container, int, StrongOrder, std::strong_ordering>(std::greater{});
+ test_ordered_map_container_spaceship_with_type<Container, int, WeakOrder, std::weak_ordering>(std::less{});
+ test_ordered_map_container_spaceship_with_type<Container, int, WeakOrder, std::weak_ordering>(std::greater{});
+ test_ordered_map_container_spaceship_with_type<Container, int, PartialOrder, std::partial_ordering>(std ::less{});
+ test_ordered_map_container_spaceship_with_type<Container, int, PartialOrder, std::partial_ordering>(std ::greater{});
// `LessAndEqComp` does not have `operator<=>`. Ordering is synthesized based on `operator<`
- test_ordered_map_container_spaceship_with_type<Container, int, LessAndEqComp, std::weak_ordering>();
-
- // Thanks to SFINAE, the following is not a compiler error but returns `false`
- struct NonComparable {};
- static_assert(!std::three_way_comparable<Container<int, NonComparable>>);
+ test_ordered_map_container_spaceship_with_type<Container, int, LessAndEqComp, std::weak_ordering>(std::less{});
return true;
}