[thirdparty/gcc.git] / libstdc++-v3 / testsuite / 28_regex / sub_match / compare_c++20.cc

// Copyright (C) 2018-2023 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.

// { dg-options "-std=gnu++2a" }
// { dg-do run { target c++2a } }
// { dg-timeout-factor 2 }

#include <regex>
#include <testsuite_hooks.h>
#include <testsuite_iterators.h>

using __gnu_test::test_container;
using __gnu_test::bidirectional_iterator_wrapper;

template<typename C> struct traits : std::char_traits<C> { };

void
test01()
{
  const std::basic_string<char, traits<char>> s0, s1 = "1";
  const std::ssub_match sm, sm2;

  VERIFY( sm.compare(sm) == 0 );
  VERIFY( sm.compare(sm2) == 0 );
  VERIFY( sm.compare(sm.str()) == 0 );
  VERIFY( sm.compare(sm.str().c_str()) == 0 );
  VERIFY( sm.compare(sm2.str()) == 0 );
  VERIFY( sm.compare(sm2.str().c_str()) == 0 );
  VERIFY( sm.compare(std::string(s1.c_str())) == -1 );
  VERIFY( sm.compare(s1.c_str()) == -1 );


  VERIFY( sm == sm2 );
  VERIFY( !(sm != sm2) );
  VERIFY( !(sm < sm2) );
  VERIFY( !(sm > sm2) );
  VERIFY( sm <= sm2 );
  VERIFY( sm >= sm2 );
  VERIFY( std::is_eq(sm <=> sm2) );

  VERIFY( sm == s0 );
  VERIFY( !(sm != s0) );
  VERIFY( !(sm < s0) );
  VERIFY( !(sm > s0) );
  VERIFY( sm <= s0 );
  VERIFY( sm >= s0 );
  VERIFY( std::is_eq(sm <=> s0) );

  VERIFY( s0 == sm );
  VERIFY( !(s0 != sm) );
  VERIFY( !(s0 < sm) );
  VERIFY( !(s0 > sm) );
  VERIFY( s0 <= sm );
  VERIFY( s0 >= sm );
  VERIFY( std::is_eq(s0 <=> sm) );

  VERIFY( sm == s0.c_str() );
  VERIFY( !(sm != s0.c_str()) );
  VERIFY( !(sm < s0.c_str()) );
  VERIFY( !(sm > s0.c_str()) );
  VERIFY( sm <= s0.c_str() );
  VERIFY( sm >= s0.c_str() );
  VERIFY( std::is_eq(sm <=> s0.c_str()) );

  VERIFY( s0.c_str() == sm );
  VERIFY( !(s0.c_str() != sm) );
  VERIFY( !(s0.c_str() < sm) );
  VERIFY( !(s0.c_str() > sm) );
  VERIFY( s0.c_str() <= sm );
  VERIFY( s0.c_str() >= sm );
  VERIFY( std::is_eq(s0.c_str() <=> sm) );

  VERIFY( !(sm == s1) );
  VERIFY( sm != s1 );
  VERIFY( sm < s1 );
  VERIFY( !(sm > s1) );
  VERIFY( sm <= s1 );
  VERIFY( !(sm >= s1) );
  VERIFY( std::is_lt(sm <=> s1) );

  VERIFY( !(sm == s1.c_str()) );
  VERIFY( sm != s1.c_str() );
  VERIFY( sm < s1.c_str() );
  VERIFY( !(sm > s1.c_str()) );
  VERIFY( sm <= s1.c_str() );
  VERIFY( !(sm >= s1.c_str()) );
  VERIFY( std::is_lt(sm <=> s1.c_str()) );

  VERIFY( !(s1.c_str() == sm) );
  VERIFY( s1.c_str() != sm );
  VERIFY( !(s1.c_str() < sm) );
  VERIFY( s1.c_str() > sm );
  VERIFY( !(s1.c_str() <= sm) );
  VERIFY( s1.c_str() >= sm );
  VERIFY( std::is_gt(s1.c_str() <=> sm) );

  VERIFY( !(sm == s1[0]) );
  VERIFY( sm != s1[0] );
  VERIFY( sm < s1[0] );
  VERIFY( !(sm > s1[0]) );
  VERIFY( sm <= s1[0] );
  VERIFY( !(sm >= s1[0]) );
  VERIFY( std::is_lt(sm <=> s1[0]) );

  VERIFY( !(s1[0] == sm) );
  VERIFY( s1[0] != sm );
  VERIFY( !(s1[0] < sm) );
  VERIFY( s1[0] > sm );
  VERIFY( !(s1[0] <= sm) );
  VERIFY( s1[0] >= sm );
  VERIFY( std::is_gt(s1[0] <=> sm) );
}

void
test02()
{
  const std::basic_string<char, traits<char>> s0, s1 = "1";
  std::csub_match sm;
  const std::csub_match sm2;
  const char c[] = "1";
  sm.matched = true;
  sm.first = c;
  sm.second = c+1;

  VERIFY( sm.compare(sm) == 0 );
  VERIFY( sm.compare(sm2) == 1 );
  VERIFY( sm.compare(sm.str()) == 0 );
  VERIFY( sm.compare(sm.str().c_str()) == 0 );
  VERIFY( sm.compare(sm2.str()) == 1 );
  VERIFY( sm.compare(sm2.str().c_str()) == 1 );
  VERIFY( sm.compare(std::string(s1.c_str())) == 0 );
  VERIFY( sm.compare(s1.c_str()) == 0 );

  VERIFY( !(sm == sm2) );
  VERIFY( sm != sm2 );
  VERIFY( !(sm < sm2) );
  VERIFY( sm > sm2 );
  VERIFY( !(sm <= sm2) );
  VERIFY( sm >= sm2 );
  VERIFY( std::is_gt(sm <=> sm2) );

  VERIFY( !(sm2 == sm) );
  VERIFY( sm2 != sm );
  VERIFY( sm2 < sm );
  VERIFY( !(sm2 > sm) );
  VERIFY( sm2 <= sm );
  VERIFY( !(sm2 >= sm) );
  VERIFY( std::is_lt(sm2 <=> sm) );

  VERIFY( !(sm == s0) );
  VERIFY( sm != s0 );
  VERIFY( !(sm < s0) );
  VERIFY( sm > s0 );
  VERIFY( !(sm <= s0) );
  VERIFY( sm >= s0 );
  VERIFY( std::is_gt(sm <=> s0) );

  VERIFY( !(sm == s0.c_str()) );
  VERIFY( sm != s0.c_str() );
  VERIFY( !(sm < s0.c_str()) );
  VERIFY( sm > s0.c_str() );
  VERIFY( !(sm <= s0.c_str()) );
  VERIFY( sm >= s0.c_str() );
  VERIFY( std::is_gt(sm <=> s0.c_str()) );

  VERIFY( !(s0.c_str() == sm) );
  VERIFY( s0.c_str() != sm );
  VERIFY( s0.c_str() < sm );
  VERIFY( !(s0.c_str() > sm) );
  VERIFY( s0.c_str() <= sm );
  VERIFY( !(s0.c_str() >= sm) );
  VERIFY( std::is_lt(s0.c_str() <=> sm) );

  VERIFY( s1 == sm );
  VERIFY( !(s1 != sm) );
  VERIFY( !(s1 < sm) );
  VERIFY( !(s1 > sm) );
  VERIFY( s1 <= sm );
  VERIFY( s1 >= sm );
  VERIFY( std::is_eq(s1 <=> sm) );

  VERIFY( sm == s1.c_str() );
  VERIFY( !(sm != s1.c_str()) );
  VERIFY( !(sm < s1.c_str()) );
  VERIFY( !(sm > s1.c_str()) );
  VERIFY( sm <= s1.c_str() );
  VERIFY( sm >= s1.c_str() );
  VERIFY( std::is_eq(sm <=> s1.c_str()) );

  VERIFY( s1.c_str() == sm );
  VERIFY( !(s1.c_str() != sm) );
  VERIFY( !(s1.c_str() < sm) );
  VERIFY( !(s1.c_str() > sm) );
  VERIFY( s1.c_str() <= sm );
  VERIFY( s1.c_str() >= sm );
  VERIFY( std::is_eq(s1.c_str() <=> sm) );

  VERIFY( sm == s1[0] );
  VERIFY( !(sm != s1[0]) );
  VERIFY( !(sm < s1[0]) );
  VERIFY( !(sm > s1[0]) );
  VERIFY( sm <= s1[0] );
  VERIFY( sm >= s1[0] );
  VERIFY( std::is_eq(sm <=> s1[0]) );

  VERIFY( s1[0] == sm );
  VERIFY( !(s1[0] != sm) );
  VERIFY( !(s1[0] < sm) );
  VERIFY( !(s1[0] > sm) );
  VERIFY( s1[0] <= sm );
  VERIFY( s1[0] >= sm );
  VERIFY( std::is_eq(s1[0] <=> sm) );
}

void
test03()
{
  const std::basic_string<char, traits<char>> s0, s1 = "1";
  const char c[] = "1";
  test_container<const char, bidirectional_iterator_wrapper> tc(c, c+1);
  std::sub_match<bidirectional_iterator_wrapper<const char>> sm;
  const std::sub_match<bidirectional_iterator_wrapper<const char>> sm2;
  sm.matched = true;
  sm.first = tc.begin();
  sm.second = tc.end();

  VERIFY( sm.compare(sm) == 0 );
  VERIFY( sm.compare(sm2) == 1 );
  VERIFY( sm.compare(sm.str()) == 0 );
  VERIFY( sm.compare(sm.str().c_str()) == 0 );
  VERIFY( sm.compare(sm2.str()) == 1 );
  VERIFY( sm.compare(sm2.str().c_str()) == 1 );
  VERIFY( sm.compare(std::string(s1.c_str())) == 0 );
  VERIFY( sm.compare(s1.c_str()) == 0 );

  VERIFY( !(sm == sm2) );
  VERIFY( sm != sm2 );
  VERIFY( !(sm < sm2) );
  VERIFY( sm > sm2 );
  VERIFY( !(sm <= sm2) );
  VERIFY( sm >= sm2 );
  VERIFY( std::is_gt(sm <=> sm2) );

  VERIFY( !(sm2 == sm) );
  VERIFY( sm2 != sm );
  VERIFY( sm2 < sm );
  VERIFY( !(sm2 > sm) );
  VERIFY( sm2 <= sm );
  VERIFY( !(sm2 >= sm) );
  VERIFY( std::is_lt(sm2 <=> sm) );

  VERIFY( !(sm == s0) );
  VERIFY( sm != s0 );
  VERIFY( !(sm < s0) );
  VERIFY( sm > s0 );
  VERIFY( !(sm <= s0) );
  VERIFY( sm >= s0 );
  VERIFY( std::is_gt(sm <=> s0) );

  VERIFY( !(sm == s0.c_str()) );
  VERIFY( sm != s0.c_str() );
  VERIFY( !(sm < s0.c_str()) );
  VERIFY( sm > s0.c_str() );
  VERIFY( !(sm <= s0.c_str()) );
  VERIFY( sm >= s0.c_str() );
  VERIFY( std::is_gt(sm <=> s0.c_str()) );

  VERIFY( !(s0.c_str() == sm) );
  VERIFY( s0.c_str() != sm );
  VERIFY( s0.c_str() < sm );
  VERIFY( !(s0.c_str() > sm) );
  VERIFY( s0.c_str() <= sm );
  VERIFY( !(s0.c_str() >= sm) );
  VERIFY( std::is_lt(s0.c_str() <=> sm) );

  VERIFY( s1 == sm );
  VERIFY( !(s1 != sm) );
  VERIFY( !(s1 < sm) );
  VERIFY( !(s1 > sm) );
  VERIFY( s1 <= sm );
  VERIFY( s1 >= sm );
  VERIFY( std::is_eq(s1 <=> sm) );

  VERIFY( sm == s1.c_str() );
  VERIFY( !(sm != s1.c_str()) );
  VERIFY( !(sm < s1.c_str()) );
  VERIFY( !(sm > s1.c_str()) );
  VERIFY( sm <= s1.c_str() );
  VERIFY( sm >= s1.c_str() );
  VERIFY( std::is_eq(sm <=> s1.c_str()) );

  VERIFY( s1.c_str() == sm );
  VERIFY( !(s1.c_str() != sm) );
  VERIFY( !(s1.c_str() < sm) );
  VERIFY( !(s1.c_str() > sm) );
  VERIFY( s1.c_str() <= sm );
  VERIFY( s1.c_str() >= sm );
  VERIFY( std::is_eq(s1.c_str() <=> sm) );

  VERIFY( sm == s1[0] );
  VERIFY( !(sm != s1[0]) );
  VERIFY( !(sm < s1[0]) );
  VERIFY( !(sm > s1[0]) );
  VERIFY( sm <= s1[0] );
  VERIFY( sm >= s1[0] );
  VERIFY( std::is_eq(sm <=> s1[0]) );

  VERIFY( s1[0] == sm );
  VERIFY( !(s1[0] != sm) );
  VERIFY( !(s1[0] < sm) );
  VERIFY( !(s1[0] > sm) );
  VERIFY( s1[0] <= sm );
  VERIFY( s1[0] >= sm );
  VERIFY( std::is_eq(s1[0] <=> sm) );
}

int main()
{
  test01();
  test02();
  test03();
}
Commit	Line	Data
83ffe9cd	1	// Copyright (C) 2018-2023 Free Software Foundation, Inc.
875d6cb3 JW	2	//
	3	// This file is part of the GNU ISO C++ Library. This library is free
	4	// software; you can redistribute it and/or modify it under the
	5	// terms of the GNU General Public License as published by the
	6	// Free Software Foundation; either version 3, or (at your option)
	7	// any later version.
	8
	9	// This library is distributed in the hope that it will be useful,
	10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	// GNU General Public License for more details.
	13
	14	// You should have received a copy of the GNU General Public License along
	15	// with this library; see the file COPYING3. If not see
	16	// <http://www.gnu.org/licenses/>.
	17
	18	// { dg-options "-std=gnu++2a" }
	19	// { dg-do run { target c++2a } }
b6a8e347	20	// { dg-timeout-factor 2 }
875d6cb3 JW	21
	22	#include <regex>
	23	#include <testsuite_hooks.h>
	24	#include <testsuite_iterators.h>
	25
	26	using __gnu_test::test_container;
	27	using __gnu_test::bidirectional_iterator_wrapper;
	28
	29	template<typename C> struct traits : std::char_traits<C> { };
	30
	31	void
	32	test01()
	33	{
	34	const std::basic_string<char, traits<char>> s0, s1 = "1";
	35	const std::ssub_match sm, sm2;
	36
	37	VERIFY( sm.compare(sm) == 0 );
	38	VERIFY( sm.compare(sm2) == 0 );
	39	VERIFY( sm.compare(sm.str()) == 0 );
	40	VERIFY( sm.compare(sm.str().c_str()) == 0 );
	41	VERIFY( sm.compare(sm2.str()) == 0 );
	42	VERIFY( sm.compare(sm2.str().c_str()) == 0 );
	43	VERIFY( sm.compare(std::string(s1.c_str())) == -1 );
	44	VERIFY( sm.compare(s1.c_str()) == -1 );
	45
	46
	47	VERIFY( sm == sm2 );
	48	VERIFY( !(sm != sm2) );
	49	VERIFY( !(sm < sm2) );
	50	VERIFY( !(sm > sm2) );
	51	VERIFY( sm <= sm2 );
	52	VERIFY( sm >= sm2 );
	53	VERIFY( std::is_eq(sm <=> sm2) );
	54
	55	VERIFY( sm == s0 );
	56	VERIFY( !(sm != s0) );
	57	VERIFY( !(sm < s0) );
	58	VERIFY( !(sm > s0) );
	59	VERIFY( sm <= s0 );
	60	VERIFY( sm >= s0 );
	61	VERIFY( std::is_eq(sm <=> s0) );
	62
	63	VERIFY( s0 == sm );
	64	VERIFY( !(s0 != sm) );
	65	VERIFY( !(s0 < sm) );
	66	VERIFY( !(s0 > sm) );
	67	VERIFY( s0 <= sm );
	68	VERIFY( s0 >= sm );
	69	VERIFY( std::is_eq(s0 <=> sm) );
	70
	71	VERIFY( sm == s0.c_str() );
	72	VERIFY( !(sm != s0.c_str()) );
	73	VERIFY( !(sm < s0.c_str()) );
	74	VERIFY( !(sm > s0.c_str()) );
	75	VERIFY( sm <= s0.c_str() );
	76	VERIFY( sm >= s0.c_str() );
	77	VERIFY( std::is_eq(sm <=> s0.c_str()) );
	78
	79	VERIFY( s0.c_str() == sm );
	80	VERIFY( !(s0.c_str() != sm) );
	81	VERIFY( !(s0.c_str() < sm) );
	82	VERIFY( !(s0.c_str() > sm) );
	83	VERIFY( s0.c_str() <= sm );
	84	VERIFY( s0.c_str() >= sm );
85	VERIFY( std::is_eq(s0.c_str() <=> sm) );
86
87	VERIFY( !(sm == s1) );
88	VERIFY( sm != s1 );
89	VERIFY( sm < s1 );
90	VERIFY( !(sm > s1) );
91	VERIFY( sm <= s1 );
92	VERIFY( !(sm >= s1) );
93	VERIFY( std::is_lt(sm <=> s1) );
94
95	VERIFY( !(sm == s1.c_str()) );
96	VERIFY( sm != s1.c_str() );
97	VERIFY( sm < s1.c_str() );
98	VERIFY( !(sm > s1.c_str()) );
99	VERIFY( sm <= s1.c_str() );
100	VERIFY( !(sm >= s1.c_str()) );
101	VERIFY( std::is_lt(sm <=> s1.c_str()) );
102
103	VERIFY( !(s1.c_str() == sm) );
104	VERIFY( s1.c_str() != sm );
105	VERIFY( !(s1.c_str() < sm) );
106	VERIFY( s1.c_str() > sm );
107	VERIFY( !(s1.c_str() <= sm) );
108	VERIFY( s1.c_str() >= sm );
109	VERIFY( std::is_gt(s1.c_str() <=> sm) );
110
111	VERIFY( !(sm == s1[0]) );
112	VERIFY( sm != s1[0] );
113	VERIFY( sm < s1[0] );
114	VERIFY( !(sm > s1[0]) );
115	VERIFY( sm <= s1[0] );
116	VERIFY( !(sm >= s1[0]) );
117	VERIFY( std::is_lt(sm <=> s1[0]) );
118
119	VERIFY( !(s1[0] == sm) );
120	VERIFY( s1[0] != sm );
121	VERIFY( !(s1[0] < sm) );
122	VERIFY( s1[0] > sm );
123	VERIFY( !(s1[0] <= sm) );
124	VERIFY( s1[0] >= sm );
125	VERIFY( std::is_gt(s1[0] <=> sm) );
126	}
127
128	void
129	test02()
130	{
131	const std::basic_string<char, traits<char>> s0, s1 = "1";
132	std::csub_match sm;
133	const std::csub_match sm2;
134	const char c[] = "1";
135	sm.matched = true;
136	sm.first = c;
137	sm.second = c+1;
138
139	VERIFY( sm.compare(sm) == 0 );
140	VERIFY( sm.compare(sm2) == 1 );
141	VERIFY( sm.compare(sm.str()) == 0 );
142	VERIFY( sm.compare(sm.str().c_str()) == 0 );
143	VERIFY( sm.compare(sm2.str()) == 1 );
144	VERIFY( sm.compare(sm2.str().c_str()) == 1 );
145	VERIFY( sm.compare(std::string(s1.c_str())) == 0 );
146	VERIFY( sm.compare(s1.c_str()) == 0 );
147
148	VERIFY( !(sm == sm2) );
149	VERIFY( sm != sm2 );
150	VERIFY( !(sm < sm2) );
151	VERIFY( sm > sm2 );
152	VERIFY( !(sm <= sm2) );
153	VERIFY( sm >= sm2 );
154	VERIFY( std::is_gt(sm <=> sm2) );
155
156	VERIFY( !(sm2 == sm) );
157	VERIFY( sm2 != sm );
158	VERIFY( sm2 < sm );
159	VERIFY( !(sm2 > sm) );
160	VERIFY( sm2 <= sm );
161	VERIFY( !(sm2 >= sm) );
162	VERIFY( std::is_lt(sm2 <=> sm) );
163
164	VERIFY( !(sm == s0) );
165	VERIFY( sm != s0 );
166	VERIFY( !(sm < s0) );
167	VERIFY( sm > s0 );
168	VERIFY( !(sm <= s0) );
169	VERIFY( sm >= s0 );
170	VERIFY( std::is_gt(sm <=> s0) );
171
172	VERIFY( !(sm == s0.c_str()) );
173	VERIFY( sm != s0.c_str() );
174	VERIFY( !(sm < s0.c_str()) );
175	VERIFY( sm > s0.c_str() );
176	VERIFY( !(sm <= s0.c_str()) );
177	VERIFY( sm >= s0.c_str() );
178	VERIFY( std::is_gt(sm <=> s0.c_str()) );
179
180	VERIFY( !(s0.c_str() == sm) );
181	VERIFY( s0.c_str() != sm );
182	VERIFY( s0.c_str() < sm );
183	VERIFY( !(s0.c_str() > sm) );
184	VERIFY( s0.c_str() <= sm );
185	VERIFY( !(s0.c_str() >= sm) );
186	VERIFY( std::is_lt(s0.c_str() <=> sm) );
187
188	VERIFY( s1 == sm );
189	VERIFY( !(s1 != sm) );
190	VERIFY( !(s1 < sm) );
191	VERIFY( !(s1 > sm) );
192	VERIFY( s1 <= sm );
193	VERIFY( s1 >= sm );
194	VERIFY( std::is_eq(s1 <=> sm) );
195
196	VERIFY( sm == s1.c_str() );
197	VERIFY( !(sm != s1.c_str()) );
198	VERIFY( !(sm < s1.c_str()) );
199	VERIFY( !(sm > s1.c_str()) );
200	VERIFY( sm <= s1.c_str() );
201	VERIFY( sm >= s1.c_str() );
202	VERIFY( std::is_eq(sm <=> s1.c_str()) );
203
204	VERIFY( s1.c_str() == sm );
205	VERIFY( !(s1.c_str() != sm) );
206	VERIFY( !(s1.c_str() < sm) );
207	VERIFY( !(s1.c_str() > sm) );
208	VERIFY( s1.c_str() <= sm );
209	VERIFY( s1.c_str() >= sm );
210	VERIFY( std::is_eq(s1.c_str() <=> sm) );
211
212	VERIFY( sm == s1[0] );
213	VERIFY( !(sm != s1[0]) );
214	VERIFY( !(sm < s1[0]) );
215	VERIFY( !(sm > s1[0]) );
216	VERIFY( sm <= s1[0] );
217	VERIFY( sm >= s1[0] );
218	VERIFY( std::is_eq(sm <=> s1[0]) );
219
220	VERIFY( s1[0] == sm );
221	VERIFY( !(s1[0] != sm) );
222	VERIFY( !(s1[0] < sm) );
223	VERIFY( !(s1[0] > sm) );
224	VERIFY( s1[0] <= sm );
225	VERIFY( s1[0] >= sm );
226	VERIFY( std::is_eq(s1[0] <=> sm) );
227	}
228
229	void
230	test03()
231	{
232	const std::basic_string<char, traits<char>> s0, s1 = "1";
233	const char c[] = "1";
234	test_container<const char, bidirectional_iterator_wrapper> tc(c, c+1);
235	std::sub_match<bidirectional_iterator_wrapper<const char>> sm;
236	const std::sub_match<bidirectional_iterator_wrapper<const char>> sm2;
237	sm.matched = true;
238	sm.first = tc.begin();
239	sm.second = tc.end();
240
241	VERIFY( sm.compare(sm) == 0 );
242	VERIFY( sm.compare(sm2) == 1 );
243	VERIFY( sm.compare(sm.str()) == 0 );
244	VERIFY( sm.compare(sm.str().c_str()) == 0 );
245	VERIFY( sm.compare(sm2.str()) == 1 );
246	VERIFY( sm.compare(sm2.str().c_str()) == 1 );
247	VERIFY( sm.compare(std::string(s1.c_str())) == 0 );
248	VERIFY( sm.compare(s1.c_str()) == 0 );
249
250	VERIFY( !(sm == sm2) );
251	VERIFY( sm != sm2 );
252	VERIFY( !(sm < sm2) );
253	VERIFY( sm > sm2 );
254	VERIFY( !(sm <= sm2) );
255	VERIFY( sm >= sm2 );
256	VERIFY( std::is_gt(sm <=> sm2) );
257
258	VERIFY( !(sm2 == sm) );
259	VERIFY( sm2 != sm );
260	VERIFY( sm2 < sm );
261	VERIFY( !(sm2 > sm) );
262	VERIFY( sm2 <= sm );
263	VERIFY( !(sm2 >= sm) );
264	VERIFY( std::is_lt(sm2 <=> sm) );
265
266	VERIFY( !(sm == s0) );
267	VERIFY( sm != s0 );
268	VERIFY( !(sm < s0) );
269	VERIFY( sm > s0 );
270	VERIFY( !(sm <= s0) );
271	VERIFY( sm >= s0 );
272	VERIFY( std::is_gt(sm <=> s0) );
273
274	VERIFY( !(sm == s0.c_str()) );
275	VERIFY( sm != s0.c_str() );
276	VERIFY( !(sm < s0.c_str()) );
277	VERIFY( sm > s0.c_str() );
278	VERIFY( !(sm <= s0.c_str()) );
279	VERIFY( sm >= s0.c_str() );
280	VERIFY( std::is_gt(sm <=> s0.c_str()) );
281
282	VERIFY( !(s0.c_str() == sm) );
283	VERIFY( s0.c_str() != sm );
284	VERIFY( s0.c_str() < sm );
285	VERIFY( !(s0.c_str() > sm) );
286	VERIFY( s0.c_str() <= sm );
287	VERIFY( !(s0.c_str() >= sm) );
288	VERIFY( std::is_lt(s0.c_str() <=> sm) );
289
290	VERIFY( s1 == sm );
291	VERIFY( !(s1 != sm) );
292	VERIFY( !(s1 < sm) );
293	VERIFY( !(s1 > sm) );
294	VERIFY( s1 <= sm );
295	VERIFY( s1 >= sm );
296	VERIFY( std::is_eq(s1 <=> sm) );
297
298	VERIFY( sm == s1.c_str() );
299	VERIFY( !(sm != s1.c_str()) );
300	VERIFY( !(sm < s1.c_str()) );
301	VERIFY( !(sm > s1.c_str()) );
302	VERIFY( sm <= s1.c_str() );
303	VERIFY( sm >= s1.c_str() );
304	VERIFY( std::is_eq(sm <=> s1.c_str()) );
305
306	VERIFY( s1.c_str() == sm );
307	VERIFY( !(s1.c_str() != sm) );
308	VERIFY( !(s1.c_str() < sm) );
309	VERIFY( !(s1.c_str() > sm) );
310	VERIFY( s1.c_str() <= sm );
311	VERIFY( s1.c_str() >= sm );
312	VERIFY( std::is_eq(s1.c_str() <=> sm) );
313
314	VERIFY( sm == s1[0] );
315	VERIFY( !(sm != s1[0]) );
316	VERIFY( !(sm < s1[0]) );
317	VERIFY( !(sm > s1[0]) );
318	VERIFY( sm <= s1[0] );
319	VERIFY( sm >= s1[0] );
320	VERIFY( std::is_eq(sm <=> s1[0]) );
321
322	VERIFY( s1[0] == sm );
323	VERIFY( !(s1[0] != sm) );
324	VERIFY( !(s1[0] < sm) );
325	VERIFY( !(s1[0] > sm) );
326	VERIFY( s1[0] <= sm );
327	VERIFY( s1[0] >= sm );
328	VERIFY( std::is_eq(s1[0] <=> sm) );
329	}
330
331	int main()
332	{
333	test01();
334	test02();
335	test03();
336	}