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 // Starting with C++20 the spaceship operator was included. This tests
10 // comparison in that context, thus doesn't support older language versions.
11 // These are tested per operator.
12
13 // UNSUPPORTED: c++03, c++11, c++14, c++17
14
15 // <string_view>
16
17 // template<class charT, class traits>
18 // constexpr bool operator==(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
19 // template<class charT, class traits>
20 // constexpr auto operator<=>(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
21 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
22
23 #include <string_view>
24
25 #include <array>
26 #include <cassert>
27 #include <string>
28
29 #include "constexpr_char_traits.h"
30 #include "make_string.h"
31 #include "test_comparisons.h"
32 #include "test_macros.h"
33
34 #define SV(S) MAKE_STRING_VIEW(CharT, S)
35
36 // Copied from constexpr_char_traits, but it doesn't have a full implementation.
37 // It has a comparison_category used in the tests.
38 template <class CharT, class Ordering>
39 struct char_traits {
40 using char_type = CharT;
41 using int_type = int;
42 using off_type = std::streamoff;
43 using pos_type = std::streampos;
44 using state_type = std::mbstate_t;
45 using comparison_category = Ordering;
46
assignchar_traits47 static constexpr void assign(char_type& __c1, const char_type& __c2) noexcept { __c1 = __c2; }
eqchar_traits48 static constexpr bool eq(char_type __c1, char_type __c2) noexcept { return __c1 == __c2; }
ltchar_traits49 static constexpr bool lt(char_type __c1, char_type __c2) noexcept { return __c1 < __c2; }
comparechar_traits50 static constexpr int compare(const char_type* __s1, const char_type* __s2, std::size_t __n) {
51 for (; __n; --__n, ++__s1, ++__s2) {
52 if (lt(*__s1, *__s2))
53 return -1;
54 if (lt(*__s2, *__s1))
55 return 1;
56 }
57 return 0;
58 }
59
60 static constexpr std::size_t length(const char_type* __s);
61 static constexpr const char_type* find(const char_type* __s, std::size_t __n, const char_type& __a);
62 static constexpr char_type* move(char_type* __s1, const char_type* __s2, std::size_t __n);
63 static constexpr char_type* copy(char_type* __s1, const char_type* __s2, std::size_t __n);
64 static constexpr char_type* assign(char_type* __s, std::size_t __n, char_type __a);
not_eofchar_traits65 static constexpr int_type not_eof(int_type __c) noexcept { return eq_int_type(__c, eof()) ? ~eof() : __c; }
to_char_typechar_traits66 static constexpr char_type to_char_type(int_type __c) noexcept { return char_type(__c); }
to_int_typechar_traits67 static constexpr int_type to_int_type(char_type __c) noexcept { return int_type(__c); }
eq_int_typechar_traits68 static constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept { return __c1 == __c2; }
eofchar_traits69 static constexpr int_type eof() noexcept { return int_type(EOF); }
70 };
71
72 template <class T, class Ordering = std::strong_ordering>
test()73 constexpr void test() {
74 AssertOrderAreNoexcept<T>();
75 AssertOrderReturn<Ordering, T>();
76
77 using CharT = typename T::value_type;
78
79 // sorted values
80 std::array v{
81 SV(""),
82 SV("abc"),
83 SV("abcdef"),
84 };
85
86 // sorted values with embedded NUL character
87 std::array vn{
88 SV("abc"),
89 SV("abc\0"),
90 SV("abc\0def"),
91 };
92 static_assert(v.size() == vn.size());
93
94 for (std::size_t i = 0; i < v.size(); ++i) {
95 for (std::size_t j = 0; j < v.size(); ++j) {
96 assert(testOrder(v[i], v[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
97 assert(testOrder(
98 v[i],
99 std::basic_string<CharT>{v[j]},
100 i == j ? Ordering::equivalent
101 : i < j ? Ordering::less
102 : Ordering::greater));
103
104 assert(testOrder(
105 v[i],
106 std::basic_string<CharT>{v[j]}.c_str(),
107 i == j ? Ordering::equivalent
108 : i < j ? Ordering::less
109 : Ordering::greater));
110
111 // NUL test omitted for c-strings since it will fail.
112 assert(testOrder(vn[i], vn[j], i == j ? Ordering::equivalent : i < j ? Ordering::less : Ordering::greater));
113 assert(testOrder(
114 vn[i],
115 std::basic_string<CharT>{vn[j]},
116 i == j ? Ordering::equivalent
117 : i < j ? Ordering::less
118 : Ordering::greater));
119 }
120 }
121 }
122
123 template <class CharT>
test_all_orderings()124 constexpr void test_all_orderings() {
125 test<std::basic_string_view<CharT>>(); // Strong ordering in its char_traits
126 test<std::basic_string_view<CharT, constexpr_char_traits<CharT>>,
127 std::weak_ordering>(); // No ordering in its char_traits
128 test<std::basic_string_view<CharT, char_traits<CharT, std::weak_ordering>>, std::weak_ordering>();
129 test<std::basic_string_view<CharT, char_traits<CharT, std::partial_ordering>>, std::partial_ordering>();
130 }
131
test_all_types()132 constexpr bool test_all_types() {
133 test_all_orderings<char>();
134 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
135 test_all_orderings<wchar_t>();
136 #endif
137 test_all_orderings<char8_t>();
138 test_all_orderings<char16_t>();
139 test_all_orderings<char32_t>();
140
141 return true;
142 }
143
main(int,char **)144 int main(int, char**) {
145 test_all_types();
146 static_assert(test_all_types());
147
148 return 0;
149 }
150