[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-2014 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)
{
  bool test __attribute__((unused)) = true;
  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
aa118a03	3	// Copyright (C) 1998-2014 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	{
11f10e6b	117	bool test __attribute__((unused)) = true;
61f1ed59 PC	118	std::wstring str_0(L"costa rica");
	119	std::wstring str_1(L"costa marbella");
	120	std::wstring str_2(L"cost");
	121	std::wstring str_3(L"costa ricans");
	122	std::wstring str_4;
b2dad0e3 BK	123
	124	str_4 = str_0;
	125	//comparisons between string objects
aa1b2f7d BV	126	VERIFY( !(str_0 == str_1) );
	127	VERIFY( !(str_0 == str_2) );
	128	VERIFY( !(str_0 == str_3) );
	129	VERIFY( !(str_1 == str_0) );
	130	VERIFY( !(str_2 == str_0) );
	131	VERIFY( !(str_3 == str_0) );
	132	VERIFY( str_4 == str_0 );
	133	VERIFY( str_0 == str_4 );
	134
	135	VERIFY( str_0 != str_1 );
	136	VERIFY( str_0 != str_2 );
	137	VERIFY( str_0 != str_3 );
	138	VERIFY( str_1 != str_0 );
	139	VERIFY( str_2 != str_0 );
	140	VERIFY( str_3 != str_0 );
	141	VERIFY( !(str_0 != str_4) );
	142	VERIFY( !(str_4 != str_0) );
b2dad0e3	143
aa1b2f7d BV	144	VERIFY( str_0 > str_1 ); //true cuz r>m
	145	VERIFY( str_0 > str_2 );
	146	VERIFY( !(str_0 > str_3) );
	147	VERIFY( !(str_1 > str_0) ); //false cuz m<r
	148	VERIFY( !(str_2 > str_0) );
	149	VERIFY( str_3 > str_0 );
	150	VERIFY( !(str_0 > str_4) );
	151	VERIFY( !(str_4 > str_0) );
	152
	153	VERIFY( !(str_0 < str_1) ); //false cuz r>m
	154	VERIFY( !(str_0 < str_2) );
	155	VERIFY( str_0 < str_3 );
	156	VERIFY( str_1 < str_0 ); //true cuz m<r
	157	VERIFY( str_2 < str_0 );
	158	VERIFY( !(str_3 < str_0) );
	159	VERIFY( !(str_0 < str_4) );
	160	VERIFY( !(str_4 < str_0) );
	161
	162	VERIFY( str_0 >= str_1 ); //true cuz r>m
	163	VERIFY( str_0 >= str_2 );
	164	VERIFY( !(str_0 >= str_3) );
	165	VERIFY( !(str_1 >= str_0) );//false cuz m<r
	166	VERIFY( !(str_2 >= str_0) );
	167	VERIFY( str_3 >= str_0 );
	168	VERIFY( str_0 >= str_4 );
	169	VERIFY( str_4 >= str_0 );
	170
	171	VERIFY( !(str_0 <= str_1) );//false cuz r>m
	172	VERIFY( !(str_0 <= str_2) );
	173	VERIFY( str_0 <= str_3 );
	174	VERIFY( str_1 <= str_0 );//true cuz m<r
	175	VERIFY( str_2 <= str_0 );
	176	VERIFY( !(str_3 <= str_0) );
	177	VERIFY( str_0 <= str_4 );
	178	VERIFY( str_4 <= str_0 );
b2dad0e3 BK	179
b2dad0e3 BK	180	//comparisons between string object and string literal
61f1ed59 PC	181	VERIFY( !(str_0 == L"costa marbella") );
	182	VERIFY( !(str_0 == L"cost") );
	183	VERIFY( !(str_0 == L"costa ricans") );
	184	VERIFY( !(L"costa marbella" == str_0) );
	185	VERIFY( !(L"cost" == str_0) );
	186	VERIFY( !(L"costa ricans" == str_0) );
	187	VERIFY( L"costa rica" == str_0 );
	188	VERIFY( str_0 == L"costa rica" );
	189
	190	VERIFY( str_0 != L"costa marbella" );
	191	VERIFY( str_0 != L"cost" );
	192	VERIFY( str_0 != L"costa ricans" );
	193	VERIFY( L"costa marbella" != str_0 );
	194	VERIFY( L"cost" != str_0 );
	195	VERIFY( L"costa ricans" != str_0 );
	196	VERIFY( !(L"costa rica" != str_0) );
	197	VERIFY( !(str_0 != L"costa rica") );
	198
	199	VERIFY( str_0 > L"costa marbella" ); //true cuz r>m
	200	VERIFY( str_0 > L"cost" );
	201	VERIFY( !(str_0 > L"costa ricans") );
	202	VERIFY( !(L"costa marbella" > str_0) );//false cuz m<r
	203	VERIFY( !(L"cost" > str_0) );
	204	VERIFY( L"costa ricans" > str_0 );
	205	VERIFY( !(L"costa rica" > str_0) );
	206	VERIFY( !(str_0 > L"costa rica") );
	207
	208	VERIFY( !(str_0 < L"costa marbella") );//false cuz r>m
	209	VERIFY( !(str_0 < L"cost") );
	210	VERIFY( str_0 < L"costa ricans" );
	211	VERIFY( L"costa marbella" < str_0 );//true cuz m<r
	212	VERIFY( L"cost" < str_0 );
	213	VERIFY( !(L"costa ricans" < str_0) );
	214	VERIFY( !(L"costa rica" < str_0) );
	215	VERIFY( !(str_0 < L"costa rica") );
	216
	217	VERIFY( str_0 >= L"costa marbella" );//true cuz r>m
	218	VERIFY( str_0 >= L"cost" );
	219	VERIFY( !(str_0 >= L"costa ricans") );
	220	VERIFY( !(L"costa marbella" >= str_0) );//false cuz m<r
	221	VERIFY( !(L"cost" >= str_0) );
	222	VERIFY( L"costa ricans" >= str_0 );
	223	VERIFY( L"costa rica" >= str_0 );
	224	VERIFY( str_0 >= L"costa rica" );
	225
	226	VERIFY( !(str_0 <= L"costa marbella") );//false cuz r>m
	227	VERIFY( !(str_0 <= L"cost") );
	228	VERIFY( str_0 <= L"costa ricans" );
	229	VERIFY( L"costa marbella" <= str_0 );//true cuz m<r
	230	VERIFY( L"cost" <= str_0 );
	231	VERIFY( !(L"costa ricans" <= str_0) );
	232	VERIFY( L"costa rica" <= str_0 );
	233	VERIFY( str_0 <= L"costa rica" );
b2dad0e3 BK	234
	235	// 21.3.7.1 operator+
	236	/*
	237	template<class charT, class traits, class Allocator>
	238	basic_string<charT,traits,Allocator>
	239	operator+(const basic_string<charT,traits,Allocator>& lhs,
	240	const basic_string<charT,traits,Allocator>& rhs);
	241
	242	template<class charT, class traits, class Allocator>
	243	basic_string<charT,traits,Allocator>
	244	operator+(const charT* lhs,
	245	const basic_string<charT,traits,Allocator>& rhs);
	246
	247	template<class charT, class traits, class Allocator>
	248	basic_string<charT,traits,Allocator>
	249	operator+(const basic_string<charT,traits,Allocator>& lhs,
	250	const charT* rhs);
	251
	252	template<class charT, class traits, class Allocator>
	253	basic_string<charT,traits,Allocator>
	254	operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
	255
	256	template<class charT, class traits, class Allocator>
	257	basic_string<charT,traits,Allocator>
	258	operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs);
	259	*/
	260
61f1ed59	261	str_4 = str_0 + L"ns";
aa1b2f7d	262	VERIFY( str_4 == str_3 );
b2dad0e3	263
61f1ed59 PC	264	const std::wstring str_5(L" marbella");
61f1ed59 PC	265	str_4 = L"costa" + str_5;
aa1b2f7d	266	VERIFY( str_4 == str_1 );
b2dad0e3	267
61f1ed59	268	std::wstring str_6(L"ns");
b2dad0e3	269	str_4 = str_0 + str_6;
aa1b2f7d	270	VERIFY( str_4 == str_3 );
b2dad0e3	271
61f1ed59 PC	272	str_4 = str_0 + L'n';
61f1ed59 PC	273	str_4 = str_4 + L's';
aa1b2f7d	274	VERIFY( str_4 == str_3 );
b2dad0e3	275
61f1ed59 PC	276	str_4 = L'a' + str_6;
	277	str_4 = L'c' + str_4;
	278	str_4 = L'i' + str_4;
	279	str_4 = L'r' + str_4;
	280	str_4 = L' ' + str_4;
	281	str_4 = L'a' + str_4;
	282	str_4 = L't' + str_4;
	283	str_4 = L's' + str_4;
	284	str_4 = L'o' + str_4;
	285	str_4 = L'c' + str_4;
aa1b2f7d	286	VERIFY( str_4 == str_3 );
b2dad0e3 BK	287	return 0;
	288	}
	289
04d930e6 BK	290	int main()
04d930e6 BK	291	{
b2dad0e3	292	test01();
04d930e6	293	return 0;
b2dad0e3	294	}