//===----------------------------------------------------------------------===// // // 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 // //===----------------------------------------------------------------------===// // // unique_ptr // template // bool // operator==(const unique_ptr& x, const unique_ptr& y); // template // bool // operator!=(const unique_ptr& x, const unique_ptr& y); // template // bool // operator< (const unique_ptr& x, const unique_ptr& y); // template // bool // operator> (const unique_ptr& x, const unique_ptr& y); // template // bool // operator<=(const unique_ptr& x, const unique_ptr& y); // template // bool // operator>=(const unique_ptr& x, const unique_ptr& y); // template // requires three_way_comparable_with::pointer, // typename unique_ptr::pointer> // compare_three_way_result_t::pointer, // typename unique_ptr::pointer> // operator<=>(const unique_ptr& x, const unique_ptr& y); #include #include #include "test_macros.h" #include "deleter_types.h" #include "test_comparisons.h" #include "unique_ptr_test_helper.h" TEST_CONSTEXPR_CXX23 bool test() { AssertComparisonsReturnBool >(); #if TEST_STD_VER > 17 AssertOrderReturn>(); #endif // Pointers of same type { A* ptr1 = new A; A* ptr2 = new A; const std::unique_ptr > p1(ptr1); const std::unique_ptr > p2(ptr2); assert(!(p1 == p2)); assert(p1 != p2); if (!TEST_IS_CONSTANT_EVALUATED) { assert((p1 < p2) == (ptr1 < ptr2)); assert((p1 <= p2) == (ptr1 <= ptr2)); assert((p1 > p2) == (ptr1 > ptr2)); assert((p1 >= p2) == (ptr1 >= ptr2)); #if TEST_STD_VER > 17 assert((p1 <=> p2) != std::strong_ordering::equal); assert((p1 <=> p2) == (ptr1 <=> ptr2)); #endif } } // Pointers of different type { A* ptr1 = new A; B* ptr2 = new B; const std::unique_ptr > p1(ptr1); const std::unique_ptr > p2(ptr2); assert(!(p1 == p2)); assert(p1 != p2); if (!TEST_IS_CONSTANT_EVALUATED) { assert((p1 < p2) == (ptr1 < ptr2)); assert((p1 <= p2) == (ptr1 <= ptr2)); assert((p1 > p2) == (ptr1 > ptr2)); assert((p1 >= p2) == (ptr1 >= ptr2)); #if TEST_STD_VER > 17 assert((p1 <=> p2) != std::strong_ordering::equal); assert((p1 <=> p2) == (ptr1 <=> ptr2)); #endif } } // Pointers of same array type { A* ptr1 = new A[3]; A* ptr2 = new A[3]; const std::unique_ptr > p1(ptr1); const std::unique_ptr > p2(ptr2); assert(!(p1 == p2)); assert(p1 != p2); if (!TEST_IS_CONSTANT_EVALUATED) { assert((p1 < p2) == (ptr1 < ptr2)); assert((p1 <= p2) == (ptr1 <= ptr2)); assert((p1 > p2) == (ptr1 > ptr2)); assert((p1 >= p2) == (ptr1 >= ptr2)); #if TEST_STD_VER > 17 assert((p1 <=> p2) != std::strong_ordering::equal); assert((p1 <=> p2) == (ptr1 <=> ptr2)); #endif } } // Pointers of different array types { A* ptr1 = new A[3]; B* ptr2 = new B[3]; const std::unique_ptr > p1(ptr1); const std::unique_ptr > p2(ptr2); assert(!(p1 == p2)); assert(p1 != p2); if (!TEST_IS_CONSTANT_EVALUATED) { assert((p1 < p2) == (ptr1 < ptr2)); assert((p1 <= p2) == (ptr1 <= ptr2)); assert((p1 > p2) == (ptr1 > ptr2)); assert((p1 >= p2) == (ptr1 >= ptr2)); #if TEST_STD_VER > 17 assert((p1 <=> p2) != std::strong_ordering::equal); assert((p1 <=> p2) == (ptr1 <=> ptr2)); #endif } } // Default-constructed pointers of same type { const std::unique_ptr > p1; const std::unique_ptr > p2; assert(p1 == p2); #if TEST_STD_VER > 17 if (!TEST_IS_CONSTANT_EVALUATED) assert((p1 <=> p2) == std::strong_ordering::equal); #endif } // Default-constructed pointers of different type { const std::unique_ptr > p1; const std::unique_ptr > p2; assert(p1 == p2); #if TEST_STD_VER > 17 if (!TEST_IS_CONSTANT_EVALUATED) assert((p1 <=> p2) == std::strong_ordering::equal); #endif } return true; } int main(int, char**) { test(); #if TEST_STD_VER >= 23 static_assert(test()); #endif return 0; }