caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[libc++][NFC] Refactored equality comparisons tests for pair and expected (#145668)

Browse Source 
Refactored `std::expected` and `std::pair` tests to use the
canonicalized names from `test_comparisions.h`, which are shared between
tests.

This was split from https://github.com/llvm/llvm-project/pull/139368 as
per comment
https://github.com/llvm/llvm-project/pull/139368#pullrequestreview-2916040573

Towards implementing [P2944R3: Comparisons for
reference_wrapper](https://github.com/llvm/llvm-project/issues/105424)

---------

Co-authored-by: Hristo Hristov <zingam@outlook.com>
Co-authored-by: Nikolas Klauser <nikolasklauser@berlin.de>
This commit is contained in:
Hristo Hristov
2025-06-29 16:34:49 +03:00
committed by GitHub
parent f21f2b483c
commit 267945b665
7 changed files with 35 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libcxx/test/std/utilities/expected/expected.expected/equality/equality.T2.pass.cpp
View File

@@ -16,14 +16,14 @@
#include <type_traits>
#include <utility>
#include "test_comparisons.h"
#include "test_macros.h"
#include "../../types.h"
#if TEST_STD_VER >= 26
// https://wg21.link/P3379R0
static_assert(CanCompare<std::expected<int, int>, int>);
static_assert(CanCompare<std::expected<int, int>, EqualityComparable>);
static_assert(!CanCompare<std::expected<int, int>, NonComparable>);
static_assert(HasOperatorEqual<std::expected<int, int>, int>);
static_assert(HasOperatorEqual<std::expected<int, int>, EqualityComparable>);
static_assert(!HasOperatorEqual<std::expected<int, int>, NonComparable>);
#endif
constexpr bool test() {

22
libcxx/test/std/utilities/expected/expected.expected/equality/equality.other_expected.pass.cpp
View File

@@ -17,26 +17,26 @@
#include <type_traits>
#include <utility>
#include "test_comparisons.h"
#include "test_macros.h"
#include "../../types.h"
// Test constraint
static_assert(!CanCompare<NonComparable, NonComparable>);
static_assert(!HasOperatorEqual<NonComparable, NonComparable>);
static_assert(CanCompare<std::expected<int, int>, std::expected<int, int>>);
static_assert(CanCompare<std::expected<int, int>, std::expected<short, short>>);
static_assert(HasOperatorEqual<std::expected<int, int>, std::expected<int, int>>);
static_assert(HasOperatorEqual<std::expected<int, int>, std::expected<short, short>>);
#if TEST_STD_VER >= 26
// https://wg21.link/P3379R0
static_assert(!CanCompare<std::expected<int, int>, std::expected<void, int>>);
static_assert(CanCompare<std::expected<int, int>, std::expected<int, int>>);
static_assert(!CanCompare<std::expected<NonComparable, int>, std::expected<NonComparable, int>>);
static_assert(!CanCompare<std::expected<int, NonComparable>, std::expected<int, NonComparable>>);
static_assert(!CanCompare<std::expected<NonComparable, int>, std::expected<int, NonComparable>>);
static_assert(!CanCompare<std::expected<int, NonComparable>, std::expected<NonComparable, int>>);
static_assert(!HasOperatorEqual<std::expected<int, int>, std::expected<void, int>>);
static_assert(HasOperatorEqual<std::expected<int, int>, std::expected<int, int>>);
static_assert(!HasOperatorEqual<std::expected<NonComparable, int>, std::expected<NonComparable, int>>);
static_assert(!HasOperatorEqual<std::expected<int, NonComparable>, std::expected<int, NonComparable>>);
static_assert(!HasOperatorEqual<std::expected<NonComparable, int>, std::expected<int, NonComparable>>);
static_assert(!HasOperatorEqual<std::expected<int, NonComparable>, std::expected<NonComparable, int>>);
#else
// Note this is true because other overloads in expected<non-void> are unconstrained
static_assert(CanCompare<std::expected<void, int>, std::expected<int, int>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::expected<int, int>>);
#endif
constexpr bool test() {
// x.has_value() && y.has_value()

8
libcxx/test/std/utilities/expected/expected.expected/equality/equality.unexpected.pass.cpp
View File

@@ -16,14 +16,14 @@
#include <type_traits>
#include <utility>
#include "test_comparisons.h"
#include "test_macros.h"
#include "../../types.h"
#if TEST_STD_VER >= 26
// https://wg21.link/P3379R0
static_assert(CanCompare<std::expected<EqualityComparable, EqualityComparable>, std::unexpected<int>>);
static_assert(CanCompare<std::expected<EqualityComparable, int>, std::unexpected<EqualityComparable>>);
static_assert(!CanCompare<std::expected<EqualityComparable, NonComparable>, std::unexpected<int>>);
static_assert(HasOperatorEqual<std::expected<EqualityComparable, EqualityComparable>, std::unexpected<int>>);
static_assert(HasOperatorEqual<std::expected<EqualityComparable, int>, std::unexpected<EqualityComparable>>);
static_assert(!HasOperatorEqual<std::expected<EqualityComparable, NonComparable>, std::unexpected<int>>);
#endif
constexpr bool test() {

22
libcxx/test/std/utilities/expected/expected.void/equality/equality.other_expected.pass.cpp
View File

@@ -17,26 +17,26 @@
#include <type_traits>
#include <utility>
#include "test_comparisons.h"
#include "test_macros.h"
#include "../../types.h"
struct Foo{};
static_assert(!CanCompare<Foo, Foo>);
static_assert(!HasOperatorEqual<Foo, Foo>);
static_assert(CanCompare<std::expected<void, int>, std::expected<void, int>>);
static_assert(CanCompare<std::expected<void, int>, std::expected<void, short>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::expected<void, int>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::expected<void, short>>);
#if TEST_STD_VER >= 26
// https://wg21.link/P3379R0
static_assert(!CanCompare<std::expected<void, int>, std::expected<int, int>>);
static_assert(CanCompare<std::expected<void, int>, std::expected<void, int>>);
static_assert(CanCompare<std::expected<void, int>, std::expected<void, int>>);
static_assert(!CanCompare<std::expected<void, NonComparable>, std::expected<void, NonComparable>>);
static_assert(!CanCompare<std::expected<void, int>, std::expected<void, NonComparable>>);
static_assert(!CanCompare<std::expected<void, NonComparable>, std::expected<void, int>>);
static_assert(!HasOperatorEqual<std::expected<void, int>, std::expected<int, int>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::expected<void, int>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::expected<void, int>>);
static_assert(!HasOperatorEqual<std::expected<void, NonComparable>, std::expected<void, NonComparable>>);
static_assert(!HasOperatorEqual<std::expected<void, int>, std::expected<void, NonComparable>>);
static_assert(!HasOperatorEqual<std::expected<void, NonComparable>, std::expected<void, int>>);
#else
// Note this is true because other overloads in expected<non-void> are unconstrained
static_assert(CanCompare<std::expected<void, int>, std::expected<int, int>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::expected<int, int>>);
#endif
constexpr bool test() {

8
libcxx/test/std/utilities/expected/expected.void/equality/equality.unexpected.pass.cpp
View File

@@ -16,14 +16,14 @@
#include <type_traits>
#include <utility>
#include "test_comparisons.h"
#include "test_macros.h"
#include "../../types.h"
#if TEST_STD_VER >= 26
// https://wg21.link/P3379R0
static_assert(CanCompare<std::expected<void, EqualityComparable>, std::unexpected<int>>);
static_assert(CanCompare<std::expected<void, int>, std::unexpected<EqualityComparable>>);
static_assert(!CanCompare<std::expected<void, NonComparable>, std::unexpected<int>>);
static_assert(HasOperatorEqual<std::expected<void, EqualityComparable>, std::unexpected<int>>);
static_assert(HasOperatorEqual<std::expected<void, int>, std::unexpected<EqualityComparable>>);
static_assert(!HasOperatorEqual<std::expected<void, NonComparable>, std::unexpected<int>>);
#endif
constexpr bool test() {

13
libcxx/test/std/utilities/expected/types.h
View File

@@ -336,17 +336,4 @@ struct CheckForInvalidWrites : public CheckForInvalidWritesBase<WithPaddedExpect
}
};
struct NonComparable {};
struct EqualityComparable {
int i;
constexpr EqualityComparable(int ii) : i(ii) {}
friend constexpr bool operator==(const EqualityComparable& data, int ii) { return data.i == ii; }
};
// Test constraint
template <class T1, class T2>
concept CanCompare = requires(T1 t1, T2 t2) { t1 == t2; };
#endif // TEST_STD_UTILITIES_EXPECTED_TYPES_H

15
libcxx/test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp
View File

@@ -21,28 +21,15 @@
#include <cassert>
#include <concepts>
#include "test_comparisons.h"
#include "test_macros.h"
#if TEST_STD_VER >= 26
// Test SFINAE.
struct EqualityComparable {
constexpr EqualityComparable(int value) : value_{value} {};
friend constexpr bool operator==(const EqualityComparable&, const EqualityComparable&) noexcept = default;
int value_;
};
static_assert(std::equality_comparable<EqualityComparable>);
static_assert(std::equality_comparable<std::pair<EqualityComparable, EqualityComparable>>);
struct NonComparable {};
static_assert(!std::equality_comparable<NonComparable>);
static_assert(!std::equality_comparable<std::pair<EqualityComparable, NonComparable>>);
static_assert(!std::equality_comparable<std::pair<NonComparable, EqualityComparable>>);