bool assign_test( ) { bool rc = true; std::string s1( 5, 'x' ); const char *shrt_string = "Shorty"; const char *long_string = "This string is longer than 8 characters"; const std::string s2( shrt_string ); const std::string s3( long_string ); std::string s4( 5, 'x' ); std::string s5( 5, 'x' ); std::string s6( 5, 'x' ); std::string s7( 5, 'x' ); std::string s8( 5, 'x' ); std::string s9( 5, 'x' ); const char *raw = "This is a very, very long string"; s1 = s2; if( s1.size( ) != 6 || s1 != shrt_string || INSANE( s1 ) ) FAIL s1 = s3; if( s1.size( ) != 39 || s1 != long_string || INSANE( s1 ) ) FAIL s4 = shrt_string; if( s4.size( ) != 6 || s4 != shrt_string || INSANE( s4 ) ) FAIL s4 = long_string; if( s4.size( ) != 39 || s4 != long_string || INSANE( s4 ) ) FAIL s5 = 'y'; if( s5.size( ) != 1 || s5 != "y" || INSANE( s5 ) ) FAIL s6.assign( s3, 35, 5 ); if( s6.size( ) != 4 || s6 != "ters" || INSANE( s6 ) ) FAIL s6.assign( s3, 5, 16 ); if( s6.size( ) != 16 || s6 != "string is longer" || INSANE( s6 ) ) FAIL s7.assign( raw, 4 ); if( s7.size( ) != 4 || s7 != "This" || INSANE( s7 ) ) FAIL s7.assign( raw, 10 ); if( s7.size( ) != 10 || s7 != "This is a " || INSANE( s7 ) ) FAIL s8.assign( "Shorty" ); if( s8.size( ) != 6 || s8 != "Shorty" || INSANE( s8 ) ) FAIL s8.assign( long_string ); if( s8.size( ) != 39 || s8 != long_string || INSANE( s8 ) ) FAIL s9.assign( 7, 'x' ); if( s9.size( ) != 7 || s9 != "xxxxxxx" || INSANE( s9 ) ) FAIL s9.assign( 8, 'y' ); if( s9.size( ) != 8 || s9 != "yyyyyyyy" || INSANE( s9 ) ) FAIL return( rc ); }
int main() { // Step(a) - construct a triangular face. Arrangement_2 arr; Segment_2 s1(Point_2(667, 1000), Point_2(4000, 5000)); Segment_2 s2(Point_2(4000, 0), Point_2(4000, 5000)); Segment_2 s3(Point_2(667, 1000), Point_2(4000, 0)); Halfedge_handle e1 = arr.insert_in_face_interior(s1, arr.unbounded_face()); Vertex_handle v1 = e1->source(); Vertex_handle v2 = e1->target(); Halfedge_handle e2 = arr.insert_from_right_vertex(s2, v2); Vertex_handle v3 = e2->target(); arr.insert_at_vertices(s3, v3, v1); // Step (b) - create additional two faces inside the triangle. Point_2 p1(4000, 3666), p2(4000, 1000); Segment_2 s4(Point_2(4000, 5000), p1); Segment_2 s5(p1, p2); Segment_2 s6(Point_2(4000, 0), p2); Halfedge_handle e4 = arr.split_edge(e2, s4, Segment_2(Point_2(4000, 0), p1)); Vertex_handle w1 = e4->target(); Halfedge_handle e5 = arr.split_edge(e4->next(), s5, s6); Vertex_handle w2 = e5->target(); Halfedge_handle e6 = e5->next(); Segment_2 s7(p1, Point_2(3000, 2666)); Segment_2 s8(p2, Point_2(3000, 1333)); Segment_2 s9(Point_2(3000, 2666), Point_2(2000, 1666)); Segment_2 s10(Point_2(3000, 1333), Point_2(2000, 1666)); Segment_2 s11(Point_2(3000, 1333), Point_2(3000, 2666)); Halfedge_handle e7 = arr.insert_from_right_vertex(s7, w1); Vertex_handle v4 = e7->target(); Halfedge_handle e8 = arr.insert_from_right_vertex(s8, w2); Vertex_handle v5 = e8->target(); Vertex_handle v6 = arr.insert_in_face_interior(Point_2(2000, 1666), e8->face()); arr.insert_at_vertices(s9, v4, v6); arr.insert_at_vertices(s10, v5, v6); arr.insert_at_vertices(s11, v4, v5); // Step(c) - remove and merge faces to form a single hole in the traingle. arr.remove_edge(e7); arr.remove_edge(e8); e5 = arr.merge_edge(e5, e6, Segment_2(e5->source()->point(), e6->target()->point())); e2 = arr.merge_edge(e4, e5, s2); print_arrangement(arr); return 0; }
void Engine::LoadScores() { iHiScore[0]= 10000; iHiScore[1]= 9000; iHiScore[2]= 8000; iHiScore[3]= 7000; iHiScore[4]= 6000; iHiScore[5]= 5000; iHiScore[6]= 4000; iHiScore[7]= 3000; iHiScore[8]= 2000; iHiScore[9]= 1000; string s1("HOLD"); string s2("DOWN"); string s3("KEYS"); string s4("MARY"); string s5("ON"); string s6("MAIN"); string s7("PAGE"); string s8("FOR"); string s9("CHEAT"); string s10("*****"); gSerializer.ReadVariable("score.dat","1a",iHiScore[0]); gSerializer.ReadVariable("score.dat","1b",s1); gSerializer.ReadVariable("score.dat","2a",iHiScore[1]); gSerializer.ReadVariable("score.dat","2b",s2); gSerializer.ReadVariable("score.dat","3a",iHiScore[2]); gSerializer.ReadVariable("score.dat","3b",s3); gSerializer.ReadVariable("score.dat","4a",iHiScore[3]); gSerializer.ReadVariable("score.dat","4b",s4); gSerializer.ReadVariable("score.dat","5a",iHiScore[4]); gSerializer.ReadVariable("score.dat","5b",s5); gSerializer.ReadVariable("score.dat","6a",iHiScore[5]); gSerializer.ReadVariable("score.dat","6b",s6); gSerializer.ReadVariable("score.dat","7a",iHiScore[6]); gSerializer.ReadVariable("score.dat","7b",s7); gSerializer.ReadVariable("score.dat","8a",iHiScore[7]); gSerializer.ReadVariable("score.dat","8b",s8); gSerializer.ReadVariable("score.dat","9a",iHiScore[8]); gSerializer.ReadVariable("score.dat","9b",s9); gSerializer.ReadVariable("score.dat","10a",iHiScore[9]); gSerializer.ReadVariable("score.dat","10b",s10); strcpy(szHiScore[0],s1.c_str()); strcpy(szHiScore[1],s2.c_str()); strcpy(szHiScore[2],s3.c_str()); strcpy(szHiScore[3],s4.c_str()); strcpy(szHiScore[4],s5.c_str()); strcpy(szHiScore[5],s6.c_str()); strcpy(szHiScore[6],s7.c_str()); strcpy(szHiScore[7],s8.c_str()); strcpy(szHiScore[8],s9.c_str()); strcpy(szHiScore[9],s10.c_str()); }
void StdStringTestCase::StdConversion() { std::string strStd("std::string value"); wxStdWideString strStdWide(L"std::wstring value"); wxString s1(strStd); CPPUNIT_ASSERT_EQUAL( "std::string value", s1 ); wxString s2(strStdWide); CPPUNIT_ASSERT_EQUAL( "std::wstring value", s2 ); wxString s3; s3 = strStd; CPPUNIT_ASSERT_EQUAL( "std::string value", s3 ); s3 = strStdWide; CPPUNIT_ASSERT_EQUAL( "std::wstring value", s3 ); wxString s4("hello"); // notice that implicit wxString -> std::string conversion is only // available in wxUSE_STL case, because it conflicts with conversion to // const char*/wchar_t* #if wxUSE_STL && wxUSE_UNSAFE_WXSTRING_CONV std::string s5 = s4; #else std::string s5 = s4.ToStdString(); #endif CPPUNIT_ASSERT_EQUAL( "hello", s5 ); #if wxUSE_STL wxStdWideString s6 = s4; #else wxStdWideString s6 = s4.ToStdWstring(); #endif CPPUNIT_ASSERT_EQUAL( "hello", s6 ); #if wxUSE_UNSAFE_WXSTRING_CONV std::string s7(s4); CPPUNIT_ASSERT( s7 == "hello" ); #endif wxStdWideString s8(s4); CPPUNIT_ASSERT( s8 == "hello" ); std::string s9("\xF0\x9F\x90\xB1\0\xE7\x8C\xAB", 9); /* U+1F431 U+0000 U+732B */ wxString s10 = wxString::FromUTF8(s9); CPPUNIT_ASSERT_EQUAL( s9, s10.ToStdString(wxConvUTF8) ); std::string s11("xyz\0\xFF", 5); /* an invalid UTF-8 sequence */ CPPUNIT_ASSERT_EQUAL( wxString::FromUTF8(s11), "" ); }
s9 f9() { return s9(); }
String AirDC::OutputSerial(int mode) { String StreamOut; switch(mode) { case 1: //Measurements output { //_p,_T,_RH,_qc,AOA,AOS String s1(_p, 6); String s2(_T, 6); String s3(_RH, 6); String s4(_qc, 6); String s5(_AOA, 6); String s6(_AOS, 6); StreamOut="$TMO,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6; //To read string on the other side /* if (Serial.find("$TMO,")) { _p = Serial.parseFloat(); // _T = Serial.parseFloat();// _RH = Serial.parseFloat();// _qc = Serial.parseFloat();// */ break; } case 2: //Air data output //_Rho,_IAS,_CAS,_TAS,_TASPCorrected,_M,_TAT,_h,_mu,_Re { String s1(_Rho, 6); String s2(_IAS, 6); String s3(_CAS, 6); String s4(_TAS, 6); String s5(_TASPCorrected, 6); String s6(_M, 6); String s7(_TAT, 6); String s8(_h, 6); String s9(_mu, 8); String s10(_Re, 6); StreamOut="$TAD,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6+','+s7+','+s8+','+s9+','+s10; break; } case 3: //Measurements uncertainty output //_up,_uT,_uRH,_uqc { String s1(_up, 6); String s2(_uT, 6); String s3(_uRH, 6); String s4(_uqc, 6); StreamOut="$TMU,"+s1+','+s2+','+s3+','+s4; break; } case 4: //Air data uncertainty output //_uRho,_uIAS,_uCAS,_uTAS,_uTAT,_uh; { String s1(_uRho, 6); String s2(_uIAS, 6); String s3(_uCAS, 6); String s4(_uTAS, 6); String s5(_uTAT, 6); String s6(_uh, 6); StreamOut="$TAU,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6; break; } case 51: //Output for Temperature Logger Example { String s1(_Rho, 6); String s2(_TAT, 2); String s3(_TAT-273.15, 2); String s4(_uTAT, 2); String s5(_p, 2); String s6(_mu, 6); String s7(hour()); String s8(minute()); String s9(second()); String s10(month()); String s11(day()); String s12(year()); String s13(millis()); StreamOut="$TEX,"+s1+','+s2+','+s3+','+s4+','+s5+','+s6+','+s7+','+s8+','+s9+','+s10+','+s11+','+s12+','+s13; break; } return StreamOut; } }
bool append_test( ) { bool rc = true; // The sizes of the test strings used here are intended to explore // both appending without reallocation and appending with re- // allocation. A string can not be reused between tests because // an enlarged capacity is never reduced. std::string s1( "123456" ); std::string s2( "x" ); s1 += s2; if( s1 != "123456x" || s1.size( ) != 7 || INSANE( s1 ) ) FAIL s1 += s2; if( s1 != "123456xx" || s1.size( ) != 8 || INSANE( s1 ) ) FAIL std::string s3( "123456" ); s3 += "x"; if( s3 != "123456x" || s3.size( ) != 7 || INSANE( s3 ) ) FAIL s3 += "y"; if( s3 != "123456xy" || s3.size( ) != 8 || INSANE( s3 ) ) FAIL std::string s4( "123456" ); s4 += 'x'; if( s4 != "123456x" || s4.size( ) != 7 || INSANE( s4 ) ) FAIL s4 += 'z'; if( s4 != "123456xz" || s4.size( ) != 8 || INSANE( s4 ) ) FAIL std::string s5( "123456" ); std::string s6( "Hello, World!" ); s5.append( s6, 12, 1 ); if( s5 != "123456!" || s5.size( ) != 7 || INSANE( s5 ) ) FAIL s5.append( s6, 0, 3 ); if( s5 != "123456!Hel" || s5.size( ) != 10 || INSANE( s5 ) ) FAIL std::string s7( "123456" ); s7.append( "fizzle", 1 ); if( s7 != "123456f" || s7.size( ) != 7 || INSANE( s7 ) ) FAIL s7.append( "fizzle", 3 ); if( s7 != "123456ffiz" || s7.size( ) != 10 || INSANE( s7 ) ) FAIL std::string s8( "123456" ); s8.append( "x" ); if( s8 != "123456x" || s8.size( ) != 7 || INSANE( s8 ) ) FAIL s8.append( "abc" ); if( s8 != "123456xabc" || s8.size( ) != 10 || INSANE( s8 ) ) FAIL std::string s9( "123456" ); s9.append( 1, 'x' ); if( s9 != "123456x" || s9.size( ) != 7 || INSANE( s9 ) ) FAIL s9.append( 3, 'y' ); if( s9 != "123456xyyy" || s9.size( ) != 10 || INSANE( s9 ) ) FAIL std::string s10( "123456" ); s10.push_back( 'z' ); if( s10 != "123456z" || s10.size( ) != 7 || INSANE( s10 ) ) FAIL s10.push_back( 'a' ); if( s10 != "123456za" || s10.size( ) != 8 || INSANE( s10 ) ) FAIL return( rc ); }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("SString_Test")); { /* Set #1 */ ACE_CString s0 ("hello"); ACE_CString s1 ("hello"); ACE_CString s2 ("world"); ACE_CString s3 ("ll"); ACE_CString s4 ("ello"); ACE_CString s5 = s1 + " " + s2; char single_character = 'z'; ACE_CString single_character_string (single_character); ACE_CString empty_string; ACE_CString zero_size_string (s1.c_str (), 0, 0, 1); if (ACE_CString::npos == 0) ACE_ERROR((LM_ERROR,"Set #1: npos is incorrect.\n")); // Not equal comparisons. Error if they are equal if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} // Equal comparisons. Error if they are not equal if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} // Substring match. Error if they are not equal if (s1.strstr (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s3.strstr (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} // Substring creation. Error if they are not equal if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.substring (4, 10).length () != 1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} // Forward search. Error if they are not equal if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s3.find (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s3.find (s1, 1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.find (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} // Reverse search. Error if they are not equal if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} // Assignment. Error if they are not equal ACE_CString s6; s6 = s0; if (s6 != s0){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} s6 = s4; if (s4 != s6){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} s6 = s5; if (s6 != s5){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;} } { /* Set #2 */ ACE_CString s0 = "hello"; ACE_CString s1 ("hello", 0, false); ACE_CString s2 ("world", 0, false); ACE_CString s3 ("ll", 0, false); ACE_CString s4 ("ello", 0, false); ACE_CString s5 = s1 + " " + s2; char single_character = 'z'; ACE_CString single_character_string (single_character); ACE_CString empty_string (0, 0, false); ACE_CString zero_size_string (s1.c_str (), 0, 0, false); // Not equal comparisons. Error if they are equal if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Equal comparisons. Error if they are not equal if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Substring match. Error if they are not equal if (s1.strstr (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s3.strstr (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Substring creation. Error if they are not equal if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Forward search. Error if they are not equal if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s3.find (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s3.find (s1, 1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.find (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Reverse search. Error if they are not equal if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Assignment. Error if they are not equal ACE_CString s6; s6 = s0; if (s6 != s0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} s6 = s4; if (s4 != s6){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} s6 = s5; if (s6 != s5){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Clear. Error if they are not equal s0.clear(); if (s0.length() != 0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} // Rep. Error if they are not equal ACE_Auto_Basic_Array_Ptr<char> s (s1.rep ()); if (ACE_OS::strlen (s.get ()) != s1.length ()) { ACE_ERROR((LM_ERROR,"Auto_ptr s:\n")); }; ACE_CString s7 (s.get ()); if (s1 != s7){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;} } { /* Set #3 */ ACE_NS_WString s0 ("hello"); ACE_NS_WString s1 ("hello"); ACE_NS_WString s2 ("world"); ACE_NS_WString s3 ("ll"); ACE_NS_WString s4 ("ello"); ACE_NS_WString s5 = s1 + " " + s2; ACE_NS_WString s6 = ("hella"); // Same length as s1, off by one char. ACE_WCHAR_T single_character = 'z'; ACE_NS_WString single_character_string (single_character); ACE_NS_WString empty_string; ACE_NS_WString zero_size_string (s1.c_str (), 0, 0); // Not equal comparisons. Error if they are equal if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1 == s6){ACE_ERROR((LM_ERROR,"Set #3: off-by-one failed\n"));return 1;} // Equal comparisons. Error if they are not equal if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} // Substring match. Error if they are not equal if (s1.strstr (s2) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s3.strstr (s1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} // Substring creation. Error if they are not equal if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} // Forward search. Error if they are not equal if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s3.find (s1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s3.find (s1, 1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.find (s2) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} // Reverse search. Error if they are not equal if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} // Assignment. Error if they are not equal ACE_NS_WString s7; s7 = s0; if (s7 != s0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} s7 = s4; if (s4 != s7){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} s7 = s5; if (s7 != s5){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} // Clear. Error if they are not equal s0.clear(); if (s0.length() != 0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;} } { /* Set #4 */ ACE_CString s1("dog"); ACE_CString s2("d"); if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if (!(s1 > s2)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if (s1 < s2){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} ACE_CString s3 ("dog"); ACE_CString s4 ("dogbert"); if (s3 == s4){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if (!(s3 < s4)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if (s3 > s4){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} ACE_CString s5 ("dogbert",3); ACE_CString s6 ("dogbert",5); if(s5 == s6){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(!(s5 < s6)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(s5 > s6){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} ACE_CString s7 ("dogbert",4); ACE_CString s8 ("dogbert",2); if(s7 == s8){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(!(s7 > s8)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(s7 < s8){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} ACE_CString s9 ("dogbert",3); ACE_CString s10 ("dogbert"); if(s9 == s10){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(!(s9 < s10)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(s9 > s10){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} ACE_CString s11 ("dogbert",5); ACE_CString s12 ("dog"); if(s11 == s12){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(!(s11 > s12)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} if(s11 < s12){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;} s11.fast_clear (); if (s11.length () != 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("fast_clear didn't yield 0 length\n"))); } { // Set 1 for ACE_SString, which is not tested ACE_SString sstr; const char *old = sstr.rep (); const char *str = "What_a_day_it_has_been"; sstr.rep (const_cast<char *>(str)); ACE_SString tmp = sstr.substring (2, 300); if (tmp.length () == 300) ACE_ERROR ((LM_ERROR, "SString substring\n")); // Constring an ACE_SString without a character pointer or from an // existing ACE_SString causes memory to be allocated that will not // be delete (apparently by design). ACE_Allocator::instance ()->free (const_cast<char *> (old)); ACE_Allocator::instance ()->free (const_cast<char *> (tmp.rep ())); } int err = testConcatenation (); err += testIterator (); err += testConstIterator (); ACE_END_TEST; return err; }