[thirdparty/binutils-gdb.git] / gdb / unittests / basic_string_view / operators / char / 2.cc

// { dg-options "-std=gnu++17" }

// Copyright (C) 2013-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/>.

// basic_string non-member functions

// operator==
/*
template<class charT, class traits, class Allocator>
  bool operator==(const basic_string<charT,traits,Allocator>& lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator==(const charT* lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator==(const basic_string<charT,traits,Allocator>& lhs,
                  const charT* rhs);
*/

// operator!=
/*
template<class charT, class traits, class Allocator>
  bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator!=(const charT* lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator!=(const basic_string<charT,traits,Allocator>& lhs, 
                  const charT* rhs);
*/

// operator<
/*
template<class charT, class traits, class Allocator>
  bool operator< (const basic_string<charT,traits,Allocator>& lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator< (const basic_string<charT,traits,Allocator>& lhs,
                  const charT* rhs);

template<class charT, class traits, class Allocator>
  bool operator< (const charT* lhs, 
                  const basic_string<charT,traits,Allocator>& rhs);
*/

// operator>
/*
template<class charT, class traits, class Allocator>
  bool operator> (const basic_string<charT,traits,Allocator>& lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator> (const basic_string<charT,traits,Allocator>& lhs,
                  const charT* rhs);

template<class charT, class traits, class Allocator>
  bool operator> (const charT* lhs,
                  const basic_string<charT,traits,Allocator>& rhs);
*/

// operator<=
/*
template<class charT, class traits, class Allocator>
  bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
                  const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
                  const charT* rhs);

template<class charT, class traits, class Allocator>
  bool operator<=(const charT* lhs,
                  const basic_string<charT,traits,Allocator>& rhs);
*/

// operator>=
/*
template<class charT, class traits, class Allocator>
  bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
                const basic_string<charT,traits,Allocator>& rhs);

template<class charT, class traits, class Allocator>
  bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
                  const charT* rhs);

template<class charT, class traits, class Allocator>
  bool operator>=(const charT* lhs,
                  const basic_string<charT,traits,Allocator>& rhs);
*/

namespace operators_2 {

static void
test01()
{
  gdb::string_view 	str_0("costa rica");
  gdb::string_view 	str_1("costa marbella");
  gdb::string_view 	str_2("cost");
  gdb::string_view	str_3("costa ricans");
  gdb::string_view      str_4;

  str_4 = str_0;
  //comparisons between string objects
  VERIFY( !(str_0 == str_1) );
  VERIFY( !(str_0 == str_2) );
  VERIFY( !(str_0 == str_3) );
  VERIFY( !(str_1 == str_0) );
  VERIFY( !(str_2 == str_0) );
  VERIFY( !(str_3 == str_0) );
  VERIFY( str_4 == str_0 );
  VERIFY( str_0 == str_4 );

  VERIFY( str_0 != str_1 );
  VERIFY( str_0 != str_2 );
  VERIFY( str_0 != str_3 );
  VERIFY( str_1 != str_0 );
  VERIFY( str_2 != str_0 );
  VERIFY( str_3 != str_0 );
  VERIFY( !(str_0 != str_4) );
  VERIFY( !(str_4 != str_0) );

  VERIFY( str_0 > str_1 ); //true cuz r>m
  VERIFY( str_0 > str_2 );
  VERIFY( !(str_0 > str_3) );
  VERIFY( !(str_1 > str_0) ); //false cuz m<r
  VERIFY( !(str_2 > str_0) );
  VERIFY( str_3 > str_0 );
  VERIFY( !(str_0 > str_4) );
  VERIFY( !(str_4 > str_0) );

  VERIFY( !(str_0 < str_1) ); //false cuz r>m
  VERIFY( !(str_0 < str_2) );
  VERIFY( str_0 < str_3 );
  VERIFY( str_1 < str_0 ); //true cuz m<r
  VERIFY( str_2 < str_0 );
  VERIFY( !(str_3 < str_0) );
  VERIFY( !(str_0 < str_4) );
  VERIFY( !(str_4 < str_0) );

  VERIFY( str_0 >= str_1 ); //true cuz r>m
  VERIFY( str_0 >= str_2 );
  VERIFY( !(str_0 >= str_3) );
  VERIFY( !(str_1 >= str_0) );//false cuz m<r
  VERIFY( !(str_2 >= str_0) );
  VERIFY( str_3 >= str_0 );
  VERIFY( str_0 >= str_4 );
  VERIFY( str_4 >= str_0 );

  VERIFY( !(str_0 <= str_1) );//false cuz r>m
  VERIFY( !(str_0 <= str_2) );
  VERIFY( str_0 <= str_3 );
  VERIFY( str_1 <= str_0 );//true cuz m<r
  VERIFY( str_2 <= str_0 );
  VERIFY( !(str_3 <= str_0) );
  VERIFY( str_0 <= str_4 );
  VERIFY( str_4 <= str_0 );

  //comparisons between string object and string literal
  VERIFY( !(str_0 == "costa marbella") );
  VERIFY( !(str_0 == "cost") );
  VERIFY( !(str_0 == "costa ricans") );
  VERIFY( !("costa marbella" == str_0) );
  VERIFY( !("cost" == str_0) );
  VERIFY( !("costa ricans" == str_0) );
  VERIFY( "costa rica" == str_0 );
  VERIFY( str_0 == "costa rica" );

  VERIFY( str_0 != "costa marbella" );
  VERIFY( str_0 != "cost" );
  VERIFY( str_0 != "costa ricans" );
  VERIFY( "costa marbella" != str_0 );
  VERIFY( "cost" != str_0 );
  VERIFY( "costa ricans" != str_0 );
  VERIFY( !("costa rica" != str_0) );
  VERIFY( !(str_0 != "costa rica") );

  VERIFY( str_0 > "costa marbella" ); //true cuz r>m
  VERIFY( str_0 > "cost" );
  VERIFY( !(str_0 > "costa ricans") );
  VERIFY( !("costa marbella" > str_0) );//false cuz m<r
  VERIFY( !("cost" > str_0) );
  VERIFY( "costa ricans" > str_0 );
  VERIFY( !("costa rica" > str_0) );
  VERIFY( !(str_0 > "costa rica") );

  VERIFY( !(str_0 < "costa marbella") );//false cuz r>m
  VERIFY( !(str_0 < "cost") );
  VERIFY( str_0 < "costa ricans" );
  VERIFY( "costa marbella" < str_0 );//true cuz m<r
  VERIFY( "cost" < str_0 );
  VERIFY( !("costa ricans" < str_0) );
  VERIFY( !("costa rica" < str_0) );
  VERIFY( !(str_0 < "costa rica") );

  VERIFY( str_0 >= "costa marbella" );//true cuz r>m
  VERIFY( str_0 >= "cost" );
  VERIFY( !(str_0 >= "costa ricans") );
  VERIFY( !("costa marbella" >= str_0) );//false cuz m<r
  VERIFY( !("cost" >= str_0) );
  VERIFY( "costa ricans" >= str_0 );
  VERIFY( "costa rica" >= str_0 );
  VERIFY( str_0 >= "costa rica" );

  VERIFY( !(str_0 <= "costa marbella") );//false cuz r>m
  VERIFY( !(str_0 <= "cost") );
  VERIFY( str_0 <= "costa ricans" );
  VERIFY( "costa marbella" <= str_0 );//true cuz m<r
  VERIFY( "cost" <= str_0 );
  VERIFY( !("costa ricans" <= str_0) );
  VERIFY( "costa rica" <= str_0 );
  VERIFY( str_0 <= "costa rica" );
}

#ifndef GDB_STRING_VIEW
constexpr bool
test02()
{
  std::string_view 	str_0("costa rica");
  std::string_view 	str_1("costa marbella");
  std::string_view 	str_2("cost");
  std::string_view	str_3("costa ricans");
  std::string_view        str_4;

#undef VERIFY
#define VERIFY(x) if (!(x)) return false

  str_4 = str_0;
  //comparisons between string objects
  VERIFY( !(str_0 == str_1) );
  VERIFY( !(str_0 == str_2) );
  VERIFY( !(str_0 == str_3) );
  VERIFY( !(str_1 == str_0) );
  VERIFY( !(str_2 == str_0) );
  VERIFY( !(str_3 == str_0) );
  VERIFY( str_4 == str_0 );
  VERIFY( str_0 == str_4 );

  VERIFY( str_0 != str_1 );
  VERIFY( str_0 != str_2 );
  VERIFY( str_0 != str_3 );
  VERIFY( str_1 != str_0 );
  VERIFY( str_2 != str_0 );
  VERIFY( str_3 != str_0 );
  VERIFY( !(str_0 != str_4) );
  VERIFY( !(str_4 != str_0) );

  VERIFY( str_0 > str_1 ); //true cuz r>m
  VERIFY( str_0 > str_2 );
  VERIFY( !(str_0 > str_3) );
  VERIFY( !(str_1 > str_0) ); //false cuz m<r
  VERIFY( !(str_2 > str_0) );
  VERIFY( str_3 > str_0 );
  VERIFY( !(str_0 > str_4) );
  VERIFY( !(str_4 > str_0) );

  VERIFY( !(str_0 < str_1) ); //false cuz r>m
  VERIFY( !(str_0 < str_2) );
  VERIFY( str_0 < str_3 );
  VERIFY( str_1 < str_0 ); //true cuz m<r
  VERIFY( str_2 < str_0 );
  VERIFY( !(str_3 < str_0) );
  VERIFY( !(str_0 < str_4) );
  VERIFY( !(str_4 < str_0) );

  VERIFY( str_0 >= str_1 ); //true cuz r>m
  VERIFY( str_0 >= str_2 );
  VERIFY( !(str_0 >= str_3) );
  VERIFY( !(str_1 >= str_0) );//false cuz m<r
  VERIFY( !(str_2 >= str_0) );
  VERIFY( str_3 >= str_0 );
  VERIFY( str_0 >= str_4 );
  VERIFY( str_4 >= str_0 );

  VERIFY( !(str_0 <= str_1) );//false cuz r>m
  VERIFY( !(str_0 <= str_2) );
  VERIFY( str_0 <= str_3 );
  VERIFY( str_1 <= str_0 );//true cuz m<r
  VERIFY( str_2 <= str_0 );
  VERIFY( !(str_3 <= str_0) );
  VERIFY( str_0 <= str_4 );
  VERIFY( str_4 <= str_0 );

  //comparisons between string object and string literal
  VERIFY( !(str_0 == "costa marbella") );
  VERIFY( !(str_0 == "cost") );
  VERIFY( !(str_0 == "costa ricans") );
  VERIFY( !("costa marbella" == str_0) );
  VERIFY( !("cost" == str_0) );
  VERIFY( !("costa ricans" == str_0) );
  VERIFY( "costa rica" == str_0 );
  VERIFY( str_0 == "costa rica" );

  VERIFY( str_0 != "costa marbella" );
  VERIFY( str_0 != "cost" );
  VERIFY( str_0 != "costa ricans" );
  VERIFY( "costa marbella" != str_0 );
  VERIFY( "cost" != str_0 );
  VERIFY( "costa ricans" != str_0 );
  VERIFY( !("costa rica" != str_0) );
  VERIFY( !(str_0 != "costa rica") );

  VERIFY( str_0 > "costa marbella" ); //true cuz r>m
  VERIFY( str_0 > "cost" );
  VERIFY( !(str_0 > "costa ricans") );
  VERIFY( !("costa marbella" > str_0) );//false cuz m<r
  VERIFY( !("cost" > str_0) );
  VERIFY( "costa ricans" > str_0 );
  VERIFY( !("costa rica" > str_0) );
  VERIFY( !(str_0 > "costa rica") );

  VERIFY( !(str_0 < "costa marbella") );//false cuz r>m
  VERIFY( !(str_0 < "cost") );
  VERIFY( str_0 < "costa ricans" );
  VERIFY( "costa marbella" < str_0 );//true cuz m<r
  VERIFY( "cost" < str_0 );
  VERIFY( !("costa ricans" < str_0) );
  VERIFY( !("costa rica" < str_0) );
  VERIFY( !(str_0 < "costa rica") );

  VERIFY( str_0 >= "costa marbella" );//true cuz r>m
  VERIFY( str_0 >= "cost" );
  VERIFY( !(str_0 >= "costa ricans") );
  VERIFY( !("costa marbella" >= str_0) );//false cuz m<r
  VERIFY( !("cost" >= str_0) );
  VERIFY( "costa ricans" >= str_0 );
  VERIFY( "costa rica" >= str_0 );
  VERIFY( str_0 >= "costa rica" );

  VERIFY( !(str_0 <= "costa marbella") );//false cuz r>m
  VERIFY( !(str_0 <= "cost") );
  VERIFY( str_0 <= "costa ricans" );
  VERIFY( "costa marbella" <= str_0 );//true cuz m<r
  VERIFY( "cost" <= str_0 );
  VERIFY( !("costa ricans" <= str_0) );
  VERIFY( "costa rica" <= str_0 );
  VERIFY( str_0 <= "costa rica" );

  return true;
}
#endif

static int
main ()
{
  test01();
#ifndef GDB_STRING_VIEW
  static_assert( test02() );
#endif
  return 0;
}

} // namespace operators_2
Commit	Line	Data
fdc11678 SM	1	// { dg-options "-std=gnu++17" }
fdc11678 SM	2
213516ef	3	// Copyright (C) 2013-2023 Free Software Foundation, Inc.
fdc11678 SM	4	//
	5	// This file is part of the GNU ISO C++ Library. This library is free
	6	// software; you can redistribute it and/or modify it under the
	7	// terms of the GNU General Public License as published by the
	8	// Free Software Foundation; either version 3, or (at your option)
	9	// any later version.
	10
	11	// This library is distributed in the hope that it will be useful,
	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	// GNU General Public License for more details.
	15
	16	// You should have received a copy of the GNU General Public License along
	17	// with this library; see the file COPYING3. If not see
	18	// <http://www.gnu.org/licenses/>.
	19
	20	// basic_string non-member functions
	21
	22	// operator==
	23	/*
	24	template<class charT, class traits, class Allocator>
	25	bool operator==(const basic_string<charT,traits,Allocator>& lhs,
	26	const basic_string<charT,traits,Allocator>& rhs);
	27
	28	template<class charT, class traits, class Allocator>
	29	bool operator==(const charT* lhs,
	30	const basic_string<charT,traits,Allocator>& rhs);
	31
	32	template<class charT, class traits, class Allocator>
	33	bool operator==(const basic_string<charT,traits,Allocator>& lhs,
	34	const charT* rhs);
	35	*/
	36
	37	// operator!=
	38	/*
	39	template<class charT, class traits, class Allocator>
	40	bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
	41	const basic_string<charT,traits,Allocator>& rhs);
	42
	43	template<class charT, class traits, class Allocator>
	44	bool operator!=(const charT* lhs,
	45	const basic_string<charT,traits,Allocator>& rhs);
	46
	47	template<class charT, class traits, class Allocator>
	48	bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
	49	const charT* rhs);
	50	*/
	51
	52	// operator<
	53	/*
	54	template<class charT, class traits, class Allocator>
	55	bool operator< (const basic_string<charT,traits,Allocator>& lhs,
	56	const basic_string<charT,traits,Allocator>& rhs);
	57
	58	template<class charT, class traits, class Allocator>
	59	bool operator< (const basic_string<charT,traits,Allocator>& lhs,
	60	const charT* rhs);
	61
	62	template<class charT, class traits, class Allocator>
	63	bool operator< (const charT* lhs,
	64	const basic_string<charT,traits,Allocator>& rhs);
	65	*/
	66
	67	// operator>
68	/*
69	template<class charT, class traits, class Allocator>
70	bool operator> (const basic_string<charT,traits,Allocator>& lhs,
71	const basic_string<charT,traits,Allocator>& rhs);
72
73	template<class charT, class traits, class Allocator>
74	bool operator> (const basic_string<charT,traits,Allocator>& lhs,
75	const charT* rhs);
76
77	template<class charT, class traits, class Allocator>
78	bool operator> (const charT* lhs,
79	const basic_string<charT,traits,Allocator>& rhs);
80	*/
81
82	// operator<=
83	/*
84	template<class charT, class traits, class Allocator>
85	bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
86	const basic_string<charT,traits,Allocator>& rhs);
87
88	template<class charT, class traits, class Allocator>
89	bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
90	const charT* rhs);
91
92	template<class charT, class traits, class Allocator>
93	bool operator<=(const charT* lhs,
94	const basic_string<charT,traits,Allocator>& rhs);
95	*/
96
97	// operator>=
98	/*
99	template<class charT, class traits, class Allocator>
100	bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
101	const basic_string<charT,traits,Allocator>& rhs);
102
103	template<class charT, class traits, class Allocator>
104	bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
105	const charT* rhs);
106
107	template<class charT, class traits, class Allocator>
108	bool operator>=(const charT* lhs,
109	const basic_string<charT,traits,Allocator>& rhs);
110	*/
111
c9638d26	112	namespace operators_2 {
fdc11678	113
dd694d77	114	static void
fdc11678 SM	115	test01()
fdc11678 SM	116	{
c9638d26 SM	117	gdb::string_view str_0("costa rica");
	118	gdb::string_view str_1("costa marbella");
	119	gdb::string_view str_2("cost");
	120	gdb::string_view str_3("costa ricans");
	121	gdb::string_view str_4;
fdc11678 SM	122
	123	str_4 = str_0;
	124	//comparisons between string objects
	125	VERIFY( !(str_0 == str_1) );
	126	VERIFY( !(str_0 == str_2) );
	127	VERIFY( !(str_0 == str_3) );
	128	VERIFY( !(str_1 == str_0) );
	129	VERIFY( !(str_2 == str_0) );
	130	VERIFY( !(str_3 == str_0) );
	131	VERIFY( str_4 == str_0 );
	132	VERIFY( str_0 == str_4 );
	133
	134	VERIFY( str_0 != str_1 );
	135	VERIFY( str_0 != str_2 );
	136	VERIFY( str_0 != str_3 );
	137	VERIFY( str_1 != str_0 );
	138	VERIFY( str_2 != str_0 );
	139	VERIFY( str_3 != str_0 );
	140	VERIFY( !(str_0 != str_4) );
	141	VERIFY( !(str_4 != str_0) );
	142
	143	VERIFY( str_0 > str_1 ); //true cuz r>m
	144	VERIFY( str_0 > str_2 );
	145	VERIFY( !(str_0 > str_3) );
	146	VERIFY( !(str_1 > str_0) ); //false cuz m<r
	147	VERIFY( !(str_2 > str_0) );
	148	VERIFY( str_3 > str_0 );
	149	VERIFY( !(str_0 > str_4) );
	150	VERIFY( !(str_4 > str_0) );
	151
	152	VERIFY( !(str_0 < str_1) ); //false cuz r>m
	153	VERIFY( !(str_0 < str_2) );
	154	VERIFY( str_0 < str_3 );
	155	VERIFY( str_1 < str_0 ); //true cuz m<r
	156	VERIFY( str_2 < str_0 );
	157	VERIFY( !(str_3 < str_0) );
	158	VERIFY( !(str_0 < str_4) );
	159	VERIFY( !(str_4 < str_0) );
	160
	161	VERIFY( str_0 >= str_1 ); //true cuz r>m
	162	VERIFY( str_0 >= str_2 );
	163	VERIFY( !(str_0 >= str_3) );
	164	VERIFY( !(str_1 >= str_0) );//false cuz m<r
	165	VERIFY( !(str_2 >= str_0) );
	166	VERIFY( str_3 >= str_0 );
	167	VERIFY( str_0 >= str_4 );
	168	VERIFY( str_4 >= str_0 );
	169
	170	VERIFY( !(str_0 <= str_1) );//false cuz r>m
	171	VERIFY( !(str_0 <= str_2) );
	172	VERIFY( str_0 <= str_3 );
	173	VERIFY( str_1 <= str_0 );//true cuz m<r
	174	VERIFY( str_2 <= str_0 );
	175	VERIFY( !(str_3 <= str_0) );
	176	VERIFY( str_0 <= str_4 );
	177	VERIFY( str_4 <= str_0 );
	178
	179	//comparisons between string object and string literal
	180	VERIFY( !(str_0 == "costa marbella") );
	181	VERIFY( !(str_0 == "cost") );
	182	VERIFY( !(str_0 == "costa ricans") );
	183	VERIFY( !("costa marbella" == str_0) );
	184	VERIFY( !("cost" == str_0) );
	185	VERIFY( !("costa ricans" == str_0) );
186	VERIFY( "costa rica" == str_0 );
187	VERIFY( str_0 == "costa rica" );
188
189	VERIFY( str_0 != "costa marbella" );
190	VERIFY( str_0 != "cost" );
191	VERIFY( str_0 != "costa ricans" );
192	VERIFY( "costa marbella" != str_0 );
193	VERIFY( "cost" != str_0 );
194	VERIFY( "costa ricans" != str_0 );
195	VERIFY( !("costa rica" != str_0) );
196	VERIFY( !(str_0 != "costa rica") );
197
198	VERIFY( str_0 > "costa marbella" ); //true cuz r>m
199	VERIFY( str_0 > "cost" );
200	VERIFY( !(str_0 > "costa ricans") );
201	VERIFY( !("costa marbella" > str_0) );//false cuz m<r
202	VERIFY( !("cost" > str_0) );
203	VERIFY( "costa ricans" > str_0 );
204	VERIFY( !("costa rica" > str_0) );
205	VERIFY( !(str_0 > "costa rica") );
206
207	VERIFY( !(str_0 < "costa marbella") );//false cuz r>m
208	VERIFY( !(str_0 < "cost") );
209	VERIFY( str_0 < "costa ricans" );
210	VERIFY( "costa marbella" < str_0 );//true cuz m<r
211	VERIFY( "cost" < str_0 );
212	VERIFY( !("costa ricans" < str_0) );
213	VERIFY( !("costa rica" < str_0) );
214	VERIFY( !(str_0 < "costa rica") );
215
216	VERIFY( str_0 >= "costa marbella" );//true cuz r>m
217	VERIFY( str_0 >= "cost" );
218	VERIFY( !(str_0 >= "costa ricans") );
219	VERIFY( !("costa marbella" >= str_0) );//false cuz m<r
220	VERIFY( !("cost" >= str_0) );
221	VERIFY( "costa ricans" >= str_0 );
222	VERIFY( "costa rica" >= str_0 );
223	VERIFY( str_0 >= "costa rica" );
224
225	VERIFY( !(str_0 <= "costa marbella") );//false cuz r>m
226	VERIFY( !(str_0 <= "cost") );
227	VERIFY( str_0 <= "costa ricans" );
228	VERIFY( "costa marbella" <= str_0 );//true cuz m<r
229	VERIFY( "cost" <= str_0 );
230	VERIFY( !("costa ricans" <= str_0) );
231	VERIFY( "costa rica" <= str_0 );
232	VERIFY( str_0 <= "costa rica" );
233	}
234
c9638d26	235	#ifndef GDB_STRING_VIEW
fdc11678 SM	236	constexpr bool
	237	test02()
	238	{
	239	std::string_view str_0("costa rica");
	240	std::string_view str_1("costa marbella");
	241	std::string_view str_2("cost");
	242	std::string_view str_3("costa ricans");
	243	std::string_view str_4;
	244
	245	#undef VERIFY
	246	#define VERIFY(x) if (!(x)) return false
	247
	248	str_4 = str_0;
	249	//comparisons between string objects
	250	VERIFY( !(str_0 == str_1) );
	251	VERIFY( !(str_0 == str_2) );
	252	VERIFY( !(str_0 == str_3) );
	253	VERIFY( !(str_1 == str_0) );
	254	VERIFY( !(str_2 == str_0) );
	255	VERIFY( !(str_3 == str_0) );
	256	VERIFY( str_4 == str_0 );
	257	VERIFY( str_0 == str_4 );
	258
	259	VERIFY( str_0 != str_1 );
	260	VERIFY( str_0 != str_2 );
	261	VERIFY( str_0 != str_3 );
	262	VERIFY( str_1 != str_0 );
	263	VERIFY( str_2 != str_0 );
	264	VERIFY( str_3 != str_0 );
	265	VERIFY( !(str_0 != str_4) );
	266	VERIFY( !(str_4 != str_0) );
	267
	268	VERIFY( str_0 > str_1 ); //true cuz r>m
	269	VERIFY( str_0 > str_2 );
	270	VERIFY( !(str_0 > str_3) );
	271	VERIFY( !(str_1 > str_0) ); //false cuz m<r
	272	VERIFY( !(str_2 > str_0) );
	273	VERIFY( str_3 > str_0 );
	274	VERIFY( !(str_0 > str_4) );
	275	VERIFY( !(str_4 > str_0) );
	276
	277	VERIFY( !(str_0 < str_1) ); //false cuz r>m
	278	VERIFY( !(str_0 < str_2) );
	279	VERIFY( str_0 < str_3 );
	280	VERIFY( str_1 < str_0 ); //true cuz m<r
	281	VERIFY( str_2 < str_0 );
	282	VERIFY( !(str_3 < str_0) );
	283	VERIFY( !(str_0 < str_4) );
	284	VERIFY( !(str_4 < str_0) );
	285
	286	VERIFY( str_0 >= str_1 ); //true cuz r>m
	287	VERIFY( str_0 >= str_2 );
	288	VERIFY( !(str_0 >= str_3) );
	289	VERIFY( !(str_1 >= str_0) );//false cuz m<r
	290	VERIFY( !(str_2 >= str_0) );
	291	VERIFY( str_3 >= str_0 );
	292	VERIFY( str_0 >= str_4 );
	293	VERIFY( str_4 >= str_0 );
	294
	295	VERIFY( !(str_0 <= str_1) );//false cuz r>m
	296	VERIFY( !(str_0 <= str_2) );
	297	VERIFY( str_0 <= str_3 );
	298	VERIFY( str_1 <= str_0 );//true cuz m<r
	299	VERIFY( str_2 <= str_0 );
300	VERIFY( !(str_3 <= str_0) );
301	VERIFY( str_0 <= str_4 );
302	VERIFY( str_4 <= str_0 );
303
304	//comparisons between string object and string literal
305	VERIFY( !(str_0 == "costa marbella") );
306	VERIFY( !(str_0 == "cost") );
307	VERIFY( !(str_0 == "costa ricans") );
308	VERIFY( !("costa marbella" == str_0) );
309	VERIFY( !("cost" == str_0) );
310	VERIFY( !("costa ricans" == str_0) );
311	VERIFY( "costa rica" == str_0 );
312	VERIFY( str_0 == "costa rica" );
313
314	VERIFY( str_0 != "costa marbella" );
315	VERIFY( str_0 != "cost" );
316	VERIFY( str_0 != "costa ricans" );
317	VERIFY( "costa marbella" != str_0 );
318	VERIFY( "cost" != str_0 );
319	VERIFY( "costa ricans" != str_0 );
320	VERIFY( !("costa rica" != str_0) );
321	VERIFY( !(str_0 != "costa rica") );
322
323	VERIFY( str_0 > "costa marbella" ); //true cuz r>m
324	VERIFY( str_0 > "cost" );
325	VERIFY( !(str_0 > "costa ricans") );
326	VERIFY( !("costa marbella" > str_0) );//false cuz m<r
327	VERIFY( !("cost" > str_0) );
328	VERIFY( "costa ricans" > str_0 );
329	VERIFY( !("costa rica" > str_0) );
330	VERIFY( !(str_0 > "costa rica") );
331
332	VERIFY( !(str_0 < "costa marbella") );//false cuz r>m
333	VERIFY( !(str_0 < "cost") );
334	VERIFY( str_0 < "costa ricans" );
335	VERIFY( "costa marbella" < str_0 );//true cuz m<r
336	VERIFY( "cost" < str_0 );
337	VERIFY( !("costa ricans" < str_0) );
338	VERIFY( !("costa rica" < str_0) );
339	VERIFY( !(str_0 < "costa rica") );
340
341	VERIFY( str_0 >= "costa marbella" );//true cuz r>m
342	VERIFY( str_0 >= "cost" );
343	VERIFY( !(str_0 >= "costa ricans") );
344	VERIFY( !("costa marbella" >= str_0) );//false cuz m<r
345	VERIFY( !("cost" >= str_0) );
346	VERIFY( "costa ricans" >= str_0 );
347	VERIFY( "costa rica" >= str_0 );
348	VERIFY( str_0 >= "costa rica" );
349
350	VERIFY( !(str_0 <= "costa marbella") );//false cuz r>m
351	VERIFY( !(str_0 <= "cost") );
352	VERIFY( str_0 <= "costa ricans" );
353	VERIFY( "costa marbella" <= str_0 );//true cuz m<r
354	VERIFY( "cost" <= str_0 );
355	VERIFY( !("costa ricans" <= str_0) );
356	VERIFY( "costa rica" <= str_0 );
357	VERIFY( str_0 <= "costa rica" );
358
359	return true;
360	}
c9638d26	361	#endif
fdc11678	362
dd694d77 SM	363	static int
dd694d77 SM	364	main ()
fdc11678 SM	365	{
fdc11678 SM	366	test01();
c9638d26	367	#ifndef GDB_STRING_VIEW
fdc11678	368	static_assert( test02() );
c9638d26 SM	369	#endif
c9638d26 SM	370	return 0;
fdc11678	371	}
c9638d26 SM	372
c9638d26 SM	373	} // namespace operators_2