Page MenuHomePhabricator
Differential D132312 Diff 476785 libcxx/test/support/test_container_comparisons.h

Changeset View

Standalone View

View Options

libcxx/test/support/test_container_comparisons.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// Utility functions to test comparisons on containers.
#include "test_comparisons.h"
MordanteUnsubmitted
Done
ReplyInline Actions

Please add include guards.

Mordante: Please add include guards.
// Implementation detail of `test_ordered_container_spaceship`
template <template <typename...> typename Container, typename Elem, typename Order>
static constexpr void test_ordered_container_spaceship_with_type() {
MordanteUnsubmitted
Done
ReplyInline Actions
template <template <typename...> typename Container, typename Elem, typename Order>
- static constexpr void test_ordered_container_spaceship_with_type() {
+ constexpr void test_ordered_container_spaceship_with_type() {
// Empty containers
Mordante:
// Empty containers
{
Container<Elem> l1;
Container<Elem> l2;
assert(testOrder(l1, l2, Order::equivalent));
}
// Identical contents
{
Container<Elem> l1{1, 1};
Container<Elem> l2{1, 1};
assert(testOrder(l1, l2, Order::equivalent));
}
// Less, due to contained values
{
Container<Elem> l1{1, 1};
Container<Elem> l2{1, 2};
assert(testOrder(l1, l2, Order::less));
}
// Greater, due to contained values
{
Container<Elem> l1{1, 3};
Container<Elem> l2{1, 2};
assert(testOrder(l1, l2, Order::greater));
}
// Shorter list
{
Container<Elem> l1{1};
Container<Elem> l2{1, 2};
assert(testOrder(l1, l2, Order::less));
}
// Longer list
{
Container<Elem> l1{1, 2};
Container<Elem> l2{1};
assert(testOrder(l1, l2, Order::greater));
}
// Unordered
if constexpr (std::is_same_v<Elem, PartialOrder>) {
Container<Elem> l1{1, std::numeric_limits<int>::min()};
Container<Elem> l2{1, 2};
assert(testOrder(l1, l2, Order::unordered));
}
}
// Tests the `operator<=>` on ordered containers
template <template <typename...> typename Container>
static constexpr bool test_ordered_container_spaceship() {
MordanteUnsubmitted
Done
ReplyInline Actions
template <template <typename...> typename Container>
- static constexpr bool test_ordered_container_spaceship() {
+ constexpr bool test_ordered_container_spaceship() {
// The container should fulfil `std::three_way_comparable`
Mordante:
// The container should fulfil `std::three_way_comparable`
static_assert(std::three_way_comparable<Container<int>>);
// Test different comparison categories
test_ordered_container_spaceship_with_type<Container, int, std::strong_ordering>();
test_ordered_container_spaceship_with_type<Container, StrongOrder, std::strong_ordering>();
test_ordered_container_spaceship_with_type<Container, WeakOrder, std::weak_ordering>();
test_ordered_container_spaceship_with_type<Container, PartialOrder, std::partial_ordering>();
// `LessAndEqComp` does not have `operator<=>`. ordering is sythesized based on `operator<`
test_ordered_container_spaceship_with_type<Container, 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<NonComparable>>);
return true;
MordanteUnsubmitted
Done
ReplyInline Actions

I think these tests can be extended a bit, it feels like they now use a small number of types. I also miss tests for <= to be true/false for certain values.

Mordante: I think these tests can be extended a bit, it feels like they now use a small number of types.
avogelsgesangAuthorUnsubmitted
Done
ReplyInline Actions

I am not sure I understand what you are asking for here

use a small number of types

which additional types would you like to see? Afaict, the test case covers enough types such that we have all comparison categories covered?

I also miss tests for <= to be true/false for certain values.

testOrder calls testComparisonsComplete which also covers <=. Or am I misunderstanding your request for additional test coverage

avogelsgesang: I am not sure I understand what you are asking for here > use a small number of types which…
MordanteUnsubmitted
Done
ReplyInline Actions

I missed the types where <=> is synthesized, but it's there too.

Mordante: I missed the types where `<=>` is synthesized, but it's there too.
}