1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// <memory>
10
11// shared_ptr
12
13// template <class T>
14// bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
15// template <class T>
16// bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
17// template <class T>
18// bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
19// template <class T>
20// bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
21// template <class T>
22// bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
23// template <class T>
24// bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
25// template <class T>
26// bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
27// template <class T>
28// bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
29// template <class T>
30// bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
31// template <class T>
32// bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
33// template <class T>
34// bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
35// template <class T>
36// bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
37// template<class T>
38// strong_ordering operator<=>(shared_ptr<T> const& x, nullptr_t) noexcept; // C++20
39
40#include <cassert>
41#include <cstddef>
42#include <memory>
43
44#include "test_macros.h"
45#include "test_comparisons.h"
46
47void do_nothing(int*) {}
48
49int main(int, char**)
50{
51 AssertComparisonsAreNoexcept<std::shared_ptr<int>, nullptr_t>();
52 AssertComparisonsAreNoexcept<nullptr_t, std::shared_ptr<int> >();
53 AssertComparisonsReturnBool<std::shared_ptr<int>, nullptr_t>();
54 AssertComparisonsReturnBool<nullptr_t, std::shared_ptr<int> >();
55#if TEST_STD_VER >= 20
56 AssertOrderAreNoexcept<std::shared_ptr<int>>();
57 AssertOrderReturn<std::strong_ordering, std::shared_ptr<int>>();
58#endif
59
60 const std::shared_ptr<int> p1(new int(1));
61 assert(!(p1 == nullptr));
62 assert(!(nullptr == p1));
63 assert(!(p1 < nullptr));
64 assert((nullptr < p1));
65 assert(!(p1 <= nullptr));
66 assert((nullptr <= p1));
67 assert((p1 > nullptr));
68 assert(!(nullptr > p1));
69 assert((p1 >= nullptr));
70 assert(!(nullptr >= p1));
71#if TEST_STD_VER >= 20
72 assert((nullptr <=> p1) == std::strong_ordering::less);
73 assert((p1 <=> nullptr) == std::strong_ordering::greater);
74#endif
75
76 const std::shared_ptr<int> p2;
77 assert((p2 == nullptr));
78 assert((nullptr == p2));
79 assert(!(p2 < nullptr));
80 assert(!(nullptr < p2));
81 assert((p2 <= nullptr));
82 assert((nullptr <= p2));
83 assert(!(p2 > nullptr));
84 assert(!(nullptr > p2));
85 assert((p2 >= nullptr));
86 assert((nullptr >= p2));
87#if TEST_STD_VER >= 20
88 assert((p2 <=> nullptr) == std::strong_ordering::equivalent);
89 assert((nullptr <=> p2) == std::strong_ordering::equivalent);
90#endif
91
92#if TEST_STD_VER >= 17
93 const std::shared_ptr<int[]> p3(new int[1]);
94 assert(!(p3 == nullptr));
95 assert(!(nullptr == p3));
96 assert(!(p3 < nullptr));
97 assert((nullptr < p3));
98 assert(!(p3 <= nullptr));
99 assert((nullptr <= p3));
100 assert((p3 > nullptr));
101 assert(!(nullptr > p3));
102 assert((p3 >= nullptr));
103 assert(!(nullptr >= p3));
104# if TEST_STD_VER >= 20
105 assert((p3 <=> nullptr) == std::strong_ordering::greater);
106 assert((nullptr <=> p3) == std::strong_ordering::less);
107# endif
108
109 const std::shared_ptr<int[]> p4;
110 assert((p4 == nullptr));
111 assert((nullptr == p4));
112 assert(!(p4 < nullptr));
113 assert(!(nullptr < p4));
114 assert((p4 <= nullptr));
115 assert((nullptr <= p4));
116 assert(!(p4 > nullptr));
117 assert(!(nullptr > p4));
118 assert((p4 >= nullptr));
119 assert((nullptr >= p4));
120# if TEST_STD_VER >= 20
121 assert((p4 <=> nullptr) == std::strong_ordering::equivalent);
122 assert((nullptr <=> p4) == std::strong_ordering::equivalent);
123# endif
124#endif
125
126 return 0;
127}
128

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