[thirdparty/gcc.git] / libstdc++-v3 / testsuite / 21_strings / basic_string / operators / wchar_t / 2.cc

// 1998-10-01, 1999-06-25 bkoz

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

// 21.3.7.1 basic_string non-member functions

// 21.3.7.2 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);
*/

// 21.3.7.3 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);
*/

// 21.3.7.4 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);
*/

// 21.3.7.5 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);
*/

//21.3.7.6 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);
*/

// 21.3.7.7 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);
*/

#include <string>
#include <testsuite_hooks.h>

int test01(void)
{
  std::wstring 	str_0(L"costa rica");
  std::wstring 	str_1(L"costa marbella");
  std::wstring 	str_2(L"cost");
  std::wstring	str_3(L"costa ricans");
  std::wstring  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 == L"costa marbella") );
  VERIFY( !(str_0 == L"cost") );
  VERIFY( !(str_0 == L"costa ricans") );
  VERIFY( !(L"costa marbella" == str_0) );
  VERIFY( !(L"cost" == str_0) );
  VERIFY( !(L"costa ricans" == str_0) );
  VERIFY( L"costa rica" == str_0 );
  VERIFY( str_0 == L"costa rica" );

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

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

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

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

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

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

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

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

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

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

  str_4 = str_0 + L"ns";
  VERIFY( str_4 == str_3 );

  const std::wstring str_5(L" marbella");
  str_4 = L"costa" + str_5;
  VERIFY( str_4 == str_1 );

  std::wstring str_6(L"ns");
  str_4 = str_0 + str_6;
  VERIFY( str_4 == str_3 );

  str_4 = str_0 + L'n';
  str_4 = str_4 + L's';
  VERIFY( str_4 == str_3 );

  str_4 = L'a' + str_6;
  str_4 = L'c' + str_4;
  str_4 = L'i' + str_4;
  str_4 = L'r' + str_4;
  str_4 = L' ' + str_4;
  str_4 = L'a' + str_4;
  str_4 = L't' + str_4;
  str_4 = L's' + str_4;
  str_4 = L'o' + str_4;
  str_4 = L'c' + str_4;
  VERIFY( str_4 == str_3 );
  return 0;
}

int main() 
{
  test01();
  return 0;
}
Commit	Line	Data
b2dad0e3 BK	1	// 1998-10-01, 1999-06-25 bkoz
b2dad0e3 BK	2
85ec4feb	3	// Copyright (C) 1998-2018 Free Software Foundation, Inc.
b2dad0e3 BK	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
748086b7	8	// Free Software Foundation; either version 3, or (at your option)
b2dad0e3 BK	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
748086b7 JJ	17	// with this library; see the file COPYING3. If not see
748086b7 JJ	18	// <http://www.gnu.org/licenses/>.
b2dad0e3 BK	19
	20	// 21.3.7.1 basic_string non-member functions
	21
	22	// 21.3.7.2 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	// 21.3.7.3 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	// 21.3.7.4 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	// 21.3.7.5 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	//21.3.7.6 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	// 21.3.7.7 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
112	#include <string>
fe413112	113	#include <testsuite_hooks.h>
b2dad0e3 BK	114
	115	int test01(void)
	116	{
61f1ed59 PC	117	std::wstring str_0(L"costa rica");
	118	std::wstring str_1(L"costa marbella");
	119	std::wstring str_2(L"cost");
	120	std::wstring str_3(L"costa ricans");
	121	std::wstring str_4;
b2dad0e3 BK	122
	123	str_4 = str_0;
	124	//comparisons between string objects
aa1b2f7d BV	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) );
b2dad0e3	142
aa1b2f7d BV	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 );
b2dad0e3 BK	178
b2dad0e3 BK	179	//comparisons between string object and string literal
61f1ed59 PC	180	VERIFY( !(str_0 == L"costa marbella") );
	181	VERIFY( !(str_0 == L"cost") );
	182	VERIFY( !(str_0 == L"costa ricans") );
	183	VERIFY( !(L"costa marbella" == str_0) );
	184	VERIFY( !(L"cost" == str_0) );
	185	VERIFY( !(L"costa ricans" == str_0) );
	186	VERIFY( L"costa rica" == str_0 );
	187	VERIFY( str_0 == L"costa rica" );
	188
	189	VERIFY( str_0 != L"costa marbella" );
	190	VERIFY( str_0 != L"cost" );
	191	VERIFY( str_0 != L"costa ricans" );
	192	VERIFY( L"costa marbella" != str_0 );
	193	VERIFY( L"cost" != str_0 );
	194	VERIFY( L"costa ricans" != str_0 );
	195	VERIFY( !(L"costa rica" != str_0) );
	196	VERIFY( !(str_0 != L"costa rica") );
	197
	198	VERIFY( str_0 > L"costa marbella" ); //true cuz r>m
	199	VERIFY( str_0 > L"cost" );
	200	VERIFY( !(str_0 > L"costa ricans") );
	201	VERIFY( !(L"costa marbella" > str_0) );//false cuz m<r
	202	VERIFY( !(L"cost" > str_0) );
	203	VERIFY( L"costa ricans" > str_0 );
	204	VERIFY( !(L"costa rica" > str_0) );
	205	VERIFY( !(str_0 > L"costa rica") );
	206
	207	VERIFY( !(str_0 < L"costa marbella") );//false cuz r>m
	208	VERIFY( !(str_0 < L"cost") );
	209	VERIFY( str_0 < L"costa ricans" );
	210	VERIFY( L"costa marbella" < str_0 );//true cuz m<r
	211	VERIFY( L"cost" < str_0 );
	212	VERIFY( !(L"costa ricans" < str_0) );
	213	VERIFY( !(L"costa rica" < str_0) );
	214	VERIFY( !(str_0 < L"costa rica") );
	215
	216	VERIFY( str_0 >= L"costa marbella" );//true cuz r>m
	217	VERIFY( str_0 >= L"cost" );
	218	VERIFY( !(str_0 >= L"costa ricans") );
	219	VERIFY( !(L"costa marbella" >= str_0) );//false cuz m<r
	220	VERIFY( !(L"cost" >= str_0) );
	221	VERIFY( L"costa ricans" >= str_0 );
	222	VERIFY( L"costa rica" >= str_0 );
	223	VERIFY( str_0 >= L"costa rica" );
	224
	225	VERIFY( !(str_0 <= L"costa marbella") );//false cuz r>m
	226	VERIFY( !(str_0 <= L"cost") );
	227	VERIFY( str_0 <= L"costa ricans" );
	228	VERIFY( L"costa marbella" <= str_0 );//true cuz m<r
	229	VERIFY( L"cost" <= str_0 );
	230	VERIFY( !(L"costa ricans" <= str_0) );
	231	VERIFY( L"costa rica" <= str_0 );
	232	VERIFY( str_0 <= L"costa rica" );
b2dad0e3 BK	233
	234	// 21.3.7.1 operator+
	235	/*
	236	template<class charT, class traits, class Allocator>
	237	basic_string<charT,traits,Allocator>
	238	operator+(const basic_string<charT,traits,Allocator>& lhs,
	239	const basic_string<charT,traits,Allocator>& rhs);
	240
	241	template<class charT, class traits, class Allocator>
	242	basic_string<charT,traits,Allocator>
	243	operator+(const charT* lhs,
	244	const basic_string<charT,traits,Allocator>& rhs);
	245
	246	template<class charT, class traits, class Allocator>
	247	basic_string<charT,traits,Allocator>
	248	operator+(const basic_string<charT,traits,Allocator>& lhs,
	249	const charT* rhs);
	250
	251	template<class charT, class traits, class Allocator>
	252	basic_string<charT,traits,Allocator>
	253	operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
	254
	255	template<class charT, class traits, class Allocator>
	256	basic_string<charT,traits,Allocator>
	257	operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs);
	258	*/
	259
61f1ed59	260	str_4 = str_0 + L"ns";
aa1b2f7d	261	VERIFY( str_4 == str_3 );
b2dad0e3	262
61f1ed59 PC	263	const std::wstring str_5(L" marbella");
61f1ed59 PC	264	str_4 = L"costa" + str_5;
aa1b2f7d	265	VERIFY( str_4 == str_1 );
b2dad0e3	266
61f1ed59	267	std::wstring str_6(L"ns");
b2dad0e3	268	str_4 = str_0 + str_6;
aa1b2f7d	269	VERIFY( str_4 == str_3 );
b2dad0e3	270
61f1ed59 PC	271	str_4 = str_0 + L'n';
61f1ed59 PC	272	str_4 = str_4 + L's';
aa1b2f7d	273	VERIFY( str_4 == str_3 );
b2dad0e3	274
61f1ed59 PC	275	str_4 = L'a' + str_6;
	276	str_4 = L'c' + str_4;
	277	str_4 = L'i' + str_4;
	278	str_4 = L'r' + str_4;
	279	str_4 = L' ' + str_4;
	280	str_4 = L'a' + str_4;
	281	str_4 = L't' + str_4;
	282	str_4 = L's' + str_4;
	283	str_4 = L'o' + str_4;
	284	str_4 = L'c' + str_4;
aa1b2f7d	285	VERIFY( str_4 == str_3 );
b2dad0e3 BK	286	return 0;
	287	}
	288
04d930e6 BK	289	int main()
04d930e6 BK	290	{
b2dad0e3	291	test01();
04d930e6	292	return 0;
b2dad0e3	293	}