[libc++] Implement `operator<=>` for `shared_ptr`

[avogelsgesang]

Summary

Implements part of:

• P1614R2 The Mothership has Landed

Fixes LWG3427

[Mordante]

Thanks for your contribution! When resolving the review comments please look whether they apply to your other patches too. (I first want to look at this patch, once approved I'll look at the others.)

For the CI, feel free to ignore the error of the format CI, this is a soft-error at the moment.

libcxx/docs/ReleaseNotes.rst

44 ↗

(On Diff #448878)

We usually only mention "larger" improvements here not every subpart of a paper.

libcxx/include/__memory/shared_ptr.h

1241

1242

The macro only needs to be used in code that works in C++03.

1242

please use __x and __y for consistency.

1353

I see this matches the Wording in the Standard, but it differs from the paper. Does this complete an LWG issue?

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp

48

Partly pre-existing, but I miss tests to validate the return type and that the function is noexcept. Can you add tests for this? See D128603 for examples.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/order.pass.cpp

8–9 ↗

(On Diff #448878)

24 ↗

(On Diff #448878)

Please remove this #if the UNSUPPORTED is the libc++ way to achieve this behaviour.

32 ↗

(On Diff #448878)

Please test all equality and comparison operators.

[avogelsgesang]

Address comments by @Mordante

[avogelsgesang]

Thanks for your contribution!

Thank you for your review!

When resolving the review comments please look whether they apply to your other patches too. (I first want to look at this patch, once approved I'll look at the others.)

I will do so. I will let you know as soon as the other reviews are updated (probably only after we land this one, so I don't have to update the other commits multiple times)

libcxx/docs/ReleaseNotes.rst

44 ↗

(On Diff #448878)

works for me - that also gets rid of the annoying merge conflict on this line which I will have with all of the other posted reviews

libcxx/include/__memory/shared_ptr.h

1353

Indeed, this fixes https://github.com/cplusplus/draft/commit/28430c71f1f3ce39f6c9a9509756bfcece270203, also known as https://cplusplus.github.io/LWG/issue3427

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp

48

Added calls to AssertComparisonsAreNoexcept, AssertComparisonsReturnBool, AssertOrderAreNoexcept, etc.

My code required additional #ifdefs, though.
Would it make sense to introduce AssertOrderReturn also for dialects < C++20, and let it gracefully degrade to AssertComparisonsReturnBool on those earlier C++ versions?

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/order.pass.cpp

32 ↗

(On Diff #448878)

Those were already tested in lt.pass.cpp and eq.pass.cpp.
I do agree, though, that the splitting across multiple files made it hard to judge the existing test coverage. Hence, I merged this test with the pre-existing lt.pass.cpp and eq.pass.cpp.
I think doing so improves readability of this test case.

[avogelsgesang]

Forgot to git add the _LIBCPP_HIDE_FROM_ABI

[avogelsgesang]

Fix templates so they also build on C++03

[avogelsgesang]

add missing include

[Mordante]

In general I'm happy, one nit remaining. I like to see the CI green before approving.

libcxx/include/__memory/shared_ptr.h

1242

Seems you missed the noexcept here, but I see it's fixed at the other location.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp

48

No I think that doesn't make sense since it changes the macro depending on the language version used. In libc++ and its tests we're used to using #if often. Sometimes we have some helper macros, but only for generic things like CONSTEXPER_AFTER_XX.

[avogelsgesang]

• Use noexcept instead of macro
• Rebase on D130855
• (Hopefully) fix CI by adding missing include (?)

[avogelsgesang]

Status: Done -> Complete

[Mordante]

Thanks, LGTM!
I'll commit this on your behalf.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3404 <https://wg21.link/LWG3404>`__","Finish removing subrange's conversions from pair-like","November 2020","","","|ranges|"
 "`3405 <https://wg21.link/LWG3405>`__","``common_view``'s converting constructor is bad, too","November 2020","|Complete|","14.0","|ranges|"
 "`3406 <https://wg21.link/LWG3406>`__","``elements_view::begin()`` and ``elements_view::end()`` have incompatible constraints","November 2020","","","|ranges|"
 "`3419 <https://wg21.link/LWG3419>`__","[algorithms.requirements]/15 doesn't reserve as many rights as it intends to","November 2020","|Nothing To Do|",""
 "`3420 <https://wg21.link/LWG3420>`__","cpp17-iterator should check that the type looks like an iterator first","November 2020","|Complete|","14.0","|ranges|"
 "`3421 <https://wg21.link/LWG3421>`__","Imperfect ADL emulation for boolean-testable","November 2020","|Nothing To Do|","","|ranges|"
 "`3425 <https://wg21.link/LWG3425>`__","``condition_variable_any`` fails to constrain its Lock parameters","November 2020","|Nothing To Do|",""
 "`3426 <https://wg21.link/LWG3426>`__","``operator<=>(const unique_ptr<T, D>&, nullptr_t)`` can't get no satisfaction","November 2020","","","|spaceship|"
-"`3427 <https://wg21.link/LWG3427>`__","``operator<=>(const shared_ptr<T>&, nullptr_t)`` definition ill-formed","November 2020","","","|spaceship|"
+"`3427 <https://wg21.link/LWG3427>`__","``operator<=>(const shared_ptr<T>&, nullptr_t)`` definition ill-formed","November 2020","|Complete|","16.0","|spaceship|"
 "`3428 <https://wg21.link/LWG3428>`__","``single_view``'s in place constructor should be explicit","November 2020","|Complete|","14.0","|ranges|"
 "`3434 <https://wg21.link/LWG3434>`__","``ios_base`` never reclaims memory for iarray and parray","November 2020","|Nothing To Do|",""
 "`3437 <https://wg21.link/LWG3437>`__","``__cpp_lib_polymorphic_allocator`` is in the wrong header","November 2020","|Complete|","14.0"
 "`3446 <https://wg21.link/LWG3446>`__","``indirectly_readable_traits`` ambiguity for types with both ``value_type`` and ``element_type``","November 2020","|Complete|","14.0","|ranges|"
 "`3448 <https://wg21.link/LWG3448>`__","``transform_view``'s ``sentinel<false>`` not comparable with ``iterator<true>``","November 2020","","","|ranges|"
 "`3449 <https://wg21.link/LWG3449>`__","``take_view`` and ``take_while_view``'s ``sentinel<false>`` not comparable with their ``const iterator``","November 2020","","","|ranges|"
 "`3453 <https://wg21.link/LWG3453>`__","Generic code cannot call ``ranges::advance(i, s)``","November 2020","|Nothing To Do|","","|ranges|"
 "`3455 <https://wg21.link/LWG3455>`__","Incorrect Postconditions on ``unique_ptr`` move assignment","November 2020","|Nothing To Do|",""

libcxx/docs/Status/SpaceshipProjects.csv

 "| `[optional.relops] <https://wg21.link/optional.relops>`_
 | `[optional.nullops] <https://wg21.link/optional.nullops>`_
 | `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| optional
 | nullopt",None,Kent Ross,|In Progress|
 "| `[variant.relops] <https://wg21.link/variant.relops>`_
 | `[variant.monostate.relops] <https://wg21.link/variant.monostate.relops>`_","| monostate
 | variant",None,Kent Ross,|In Progress|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| `unique_ptr <https://reviews.llvm.org/D130838>`_,[comparisons.three.way],Adrian Vogelsgesang,|In Progress|
-| `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|In Progress|
+| `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[type.index.members] <https://wg21.link/type.index.members>`_,| type_index,None,Unassigned,|Not Started|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| to_chars_result,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| from_chars_result,None,Mark de Wever,|Complete|
 | `[stacktrace.entry.cmp] <https://wg21.link/stacktrace.entry.cmp>`_,| stacktrace_entry,None,Unassigned,|Not Started|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| basic_stacktrace,[alg.three.way],Unassigned,|Not Started|
 | `[string.cmp] <https://wg21.link/string.cmp>`_,| basic_string,None,Mark de Wever,|In Progress|
 | `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,| `basic_string_view <https://reviews.llvm.org/D130295>`_,None,Mark de Wever,|In Progress|
 | `[array.syn] <https://wg21.link/array.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| array,[expos.only.func],Unassigned,|Not Started|

libcxx/include/__memory/shared_ptr.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_SHARED_PTR_H
 #define _LIBCPP___MEMORY_SHARED_PTR_H
 
 #include <__availability>
+#include <__compare/compare_three_way.h>
+#include <__compare/ordering.h>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>

 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return __x.get() == __y.get();
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return !(__x == __y);
 }
 

 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return !(__x < __y);
 }
 
+#endif // _LIBCPP_STD_VER <= 17
+
+#if _LIBCPP_STD_VER > 17
+template<class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI strong_ordering
+operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept
+{
+    return compare_three_way()(__x.get(), __y.get());
+}
+#endif
+
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return !__x;
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return !__x;
 }
 

 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return !(nullptr < __x);
 }
 
+#endif // _LIBCPP_STD_VER <= 17
+
+#if _LIBCPP_STD_VER > 17
+template<class _Tp>
+_LIBCPP_HIDE_FROM_ABI strong_ordering
+operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept
+{
+    return compare_three_way()(__x.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr));
+}
+#endif
+
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 

libcxx/include/memory

 shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
 template<class T, class D>
 shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
 
 // shared_ptr comparisons:
 template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
-    bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;               // removed in C++20
 template<class T, class U>
-    bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;                // removed in C++20
 template<class T, class U>
-    bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;                // removed in C++20
 template<class T, class U>
-    bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;               // removed in C++20
 template<class T, class U>
-    bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
+    bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;               // removed in C++20
+template<class T, class U>
+    strong_ordering operator<=>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;   // C++20
 
 template <class T>
     bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
-    bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
+template <class T>
+    bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;               // removed in C++20
 template <class T>
-    bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
 template <class T>
-    bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;                // removed in C++20
 template <class T>
-    bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;                // removed in C++20
 template <class T>
-bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;               // removed in C++20
 template <class T>
-    bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
 template <class T>
-    bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;                // removed in C++20
 template <class T>
-    bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
+    bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;                // removed in C++20
 template <class T>
-    bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;               // removed in C++20
 template <class T>
-    bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
-template <class T>
-    bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
+    bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;               // removed in C++20
+template<class T>
+    strong_ordering operator<=>(shared_ptr<T> const& x, nullptr_t) noexcept;   // C++20
 
 // shared_ptr specialized algorithms:
 template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 
 // shared_ptr casts:
 template<class T, class U>
     shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept;
 template<class T, class U>

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b);
+// template<class T, class U> bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b);
+// template<class T, class U> bool operator< (const shared_ptr<T>& a, const shared_ptr<U>& b);
+// template<class T, class U> bool operator<=(const shared_ptr<T>& a, const shared_ptr<U>& b);
+// template<class T, class U> bool operator> (const shared_ptr<T>& a, const shared_ptr<U>& b);
+// template<class T, class U> bool operator>=(const shared_ptr<T>& a, const shared_ptr<U>& b);
+// template<class T1, class D1, class T2, class D2>
+//   requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
+//                                      typename unique_ptr<T2, D2>::pointer>
+//   compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
+//                              typename unique_ptr<T2, D2>::pointer>
+//     operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_comparisons.h"
+
+void do_nothing(int*) {}
+
+int main(int, char**) {
+  AssertComparisonsAreNoexcept<std::shared_ptr<int> >();
+  AssertComparisonsReturnBool<std::shared_ptr<int> >();
+#if TEST_STD_VER > 17
+  AssertOrderAreNoexcept<std::shared_ptr<int>>();
+  AssertOrderReturn<std::strong_ordering, std::shared_ptr<int>>();
+#endif
+
+  int* ptr1(new int);
+  int* ptr2(new int);
+  const std::shared_ptr<int> p1(ptr1);
+  const std::shared_ptr<int> p2(ptr2);
+
+  assert(!(p1 == p2));
+  assert(p1 != p2);
+  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
+
+  // The deleter does not influence the comparisons
+  // of the `shared_ptr`
+  const std::shared_ptr<int> p3(ptr2, do_nothing);
+  assert(p2 == p3);
+  assert(!(p1 == p3));
+  assert(!(p2 != p3));
+  assert(p1 != p3);
+  assert((p1 < p3) == (ptr1 < ptr2));
+  assert((p1 <= p3) == (ptr1 <= ptr2));
+  assert((p1 > p3) == (ptr1 > ptr2));
+  assert((p1 >= p3) == (ptr1 >= ptr2));
+#if TEST_STD_VER > 17
+  assert((p2 <=> p3) == std::strong_ordering::equal);
+  assert((p1 <=> p3) != std::strong_ordering::equal);
+  assert((p1 <=> p3) == (ptr1 <=> ptr2));
+#endif
+
+  return 0;
+}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/cmp_nullptr.pass.cpp

 // template <class T>
 //     bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
 // template <class T>
 //     bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
 // template <class T>
 //     bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
 // template <class T>
 //     bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
+// template<class T>
+//     strong_ordering operator<=>(shared_ptr<T> const& x, nullptr_t) noexcept;   // C++20
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_comparisons.h"
 
 void do_nothing(int*) {}
 
 int main(int, char**)
 {
-    const std::shared_ptr<int> p1(new int(1));
-    assert(!(p1 == nullptr));
-    assert(!(nullptr == p1));
-    assert(!(p1 < nullptr));
-    assert( (nullptr < p1));
-    assert(!(p1 <= nullptr));
-    assert( (nullptr <= p1));
-    assert( (p1 > nullptr));
-    assert(!(nullptr > p1));
-    assert( (p1 >= nullptr));
-    assert(!(nullptr >= p1));
+  AssertComparisonsAreNoexcept<std::shared_ptr<int>, nullptr_t>();
+  AssertComparisonsAreNoexcept<nullptr_t, std::shared_ptr<int> >();
+  AssertComparisonsReturnBool<std::shared_ptr<int>, nullptr_t>();
+  AssertComparisonsReturnBool<nullptr_t, std::shared_ptr<int> >();
+#if TEST_STD_VER > 17
+  AssertOrderAreNoexcept<std::shared_ptr<int>>();
+  AssertOrderReturn<std::strong_ordering, std::shared_ptr<int>>();
+#endif
+
+  assert((nullptr < p1));
+  assert((nullptr <= p1));
+  assert((p1 > nullptr));
+  assert((p1 >= nullptr));
+#if TEST_STD_VER > 17
+  assert((nullptr <=> p1) == std::strong_ordering::less);
+  assert((p1 <=> nullptr) == std::strong_ordering::greater);
+#endif
 
-    const std::shared_ptr<int> p2;
-    assert( (p2 == nullptr));
-    assert( (nullptr == p2));
-    assert(!(p2 < nullptr));
-    assert(!(nullptr < p2));
-    assert( (p2 <= nullptr));
-    assert( (nullptr <= p2));
-    assert(!(p2 > nullptr));
-    assert(!(nullptr > p2));
-    assert( (p2 >= nullptr));
-    assert( (nullptr >= p2));
+  assert((p2 == nullptr));
+  assert((nullptr == p2));
+  assert((p2 <= nullptr));
+  assert((nullptr <= p2));
+  assert((p2 >= nullptr));
+  assert((nullptr >= p2));
+#if TEST_STD_VER > 17
+  assert((nullptr <=> p2) == std::strong_ordering::equivalent);
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/eq.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// <memory>
-
-// shared_ptr
-
-// template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b);
-// template<class T, class U> bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b);
-
-#include <memory>
-#include <cassert>
-
-#include "test_macros.h"
-
-void do_nothing(int*) {}
-
-int main(int, char**)
-{
-    int* ptr1(new int);
-    int* ptr2(new int);
-    const std::shared_ptr<int> p1(ptr1);
-    const std::shared_ptr<int> p2(ptr2);
-    const std::shared_ptr<int> p3(ptr2, do_nothing);
-    assert(p1 != p2);
-    assert(p2 == p3);
-
-  return 0;
-}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cmp/lt.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// <memory>
-
-// shared_ptr
-
-// template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b);
-
-#include <memory>
-#include <cassert>
-
-#include "test_macros.h"
-
-void do_nothing(int*) {}
-
-int main(int, char**)
-{
-    int* ptr1(new int);
-    int* ptr2(new int);
-    const std::shared_ptr<int> p1(ptr1);
-    const std::shared_ptr<int> p2(ptr2);
-    const std::shared_ptr<int> p3(ptr2, do_nothing);
-    assert((p1 < p2) == (ptr1 < ptr2));
-    assert(!(p2 < p3) && !(p3 < p2));
-
-  return 0;
-}