+ CPPUNIT_ASSERT_EQUAL( "", s2u );
+ CPPUNIT_ASSERT_EQUAL( "", s2l );
+
+
+ wxString s3("good bye");
+ CPPUNIT_ASSERT_EQUAL( "Good bye", s3.Capitalize() );
+ s3.MakeCapitalized();
+ CPPUNIT_ASSERT_EQUAL( "Good bye", s3 );
+
+ CPPUNIT_ASSERT_EQUAL( "Abc", wxString("ABC").Capitalize() );
+
+ CPPUNIT_ASSERT_EQUAL( "", wxString().Capitalize() );
+}
+
+void StringTestCase::Compare()
+{
+ wxString s1 = wxT("AHH");
+ wxString eq = wxT("AHH");
+ wxString neq1 = wxT("HAH");
+ wxString neq2 = wxT("AH");
+ wxString neq3 = wxT("AHHH");
+ wxString neq4 = wxT("AhH");
+
+ CPPUNIT_ASSERT( s1 == eq );
+ CPPUNIT_ASSERT( s1 != neq1 );
+ CPPUNIT_ASSERT( s1 != neq2 );
+ CPPUNIT_ASSERT( s1 != neq3 );
+ CPPUNIT_ASSERT( s1 != neq4 );
+
+ CPPUNIT_ASSERT( s1 == wxT("AHH") );
+ CPPUNIT_ASSERT( s1 != wxT("no") );
+ CPPUNIT_ASSERT( s1 < wxT("AZ") );
+ CPPUNIT_ASSERT( s1 <= wxT("AZ") );
+ CPPUNIT_ASSERT( s1 <= wxT("AHH") );
+ CPPUNIT_ASSERT( s1 > wxT("AA") );
+ CPPUNIT_ASSERT( s1 >= wxT("AA") );
+ CPPUNIT_ASSERT( s1 >= wxT("AHH") );
+
+ // test comparison with C strings in Unicode build (must work in ANSI as
+ // well, of course):
+ CPPUNIT_ASSERT( s1 == "AHH" );
+ CPPUNIT_ASSERT( s1 != "no" );
+ CPPUNIT_ASSERT( s1 < "AZ" );
+ CPPUNIT_ASSERT( s1 <= "AZ" );
+ CPPUNIT_ASSERT( s1 <= "AHH" );
+ CPPUNIT_ASSERT( s1 > "AA" );
+ CPPUNIT_ASSERT( s1 >= "AA" );
+ CPPUNIT_ASSERT( s1 >= "AHH" );
+
+// wxString _s1 = wxT("A\0HH");
+// wxString _eq = wxT("A\0HH");
+// wxString _neq1 = wxT("H\0AH");
+// wxString _neq2 = wxT("A\0H");
+// wxString _neq3 = wxT("A\0HHH");
+// wxString _neq4 = wxT("A\0hH");
+ s1.insert(1,1,'\0');
+ eq.insert(1,1,'\0');
+ neq1.insert(1,1,'\0');
+ neq2.insert(1,1,'\0');
+ neq3.insert(1,1,'\0');
+ neq4.insert(1,1,'\0');
+
+ CPPUNIT_ASSERT( s1 == eq );
+ CPPUNIT_ASSERT( s1 != neq1 );
+ CPPUNIT_ASSERT( s1 != neq2 );
+ CPPUNIT_ASSERT( s1 != neq3 );
+ CPPUNIT_ASSERT( s1 != neq4 );
+}
+
+void StringTestCase::CompareNoCase()
+{
+ wxString s1 = wxT("AHH");
+ wxString eq = wxT("AHH");
+ wxString eq2 = wxT("AhH");
+ wxString eq3 = wxT("ahh");
+ wxString neq = wxT("HAH");
+ wxString neq2 = wxT("AH");
+ wxString neq3 = wxT("AHHH");
+
+ #define CPPUNIT_CNCEQ_ASSERT(s1, s2) CPPUNIT_ASSERT( s1.CmpNoCase(s2) == 0)
+ #define CPPUNIT_CNCNEQ_ASSERT(s1, s2) CPPUNIT_ASSERT( s1.CmpNoCase(s2) != 0)
+
+ CPPUNIT_CNCEQ_ASSERT( s1, eq );
+ CPPUNIT_CNCEQ_ASSERT( s1, eq2 );
+ CPPUNIT_CNCEQ_ASSERT( s1, eq3 );
+
+ CPPUNIT_CNCNEQ_ASSERT( s1, neq );
+ CPPUNIT_CNCNEQ_ASSERT( s1, neq2 );
+ CPPUNIT_CNCNEQ_ASSERT( s1, neq3 );
+
+
+// wxString _s1 = wxT("A\0HH");
+// wxString _eq = wxT("A\0HH");
+// wxString _eq2 = wxT("A\0hH");
+// wxString _eq3 = wxT("a\0hh");
+// wxString _neq = wxT("H\0AH");
+// wxString _neq2 = wxT("A\0H");
+// wxString _neq3 = wxT("A\0HHH");
+
+ s1.insert(1,1,'\0');
+ eq.insert(1,1,'\0');
+ eq2.insert(1,1,'\0');
+ eq3.insert(1,1,'\0');
+ neq.insert(1,1,'\0');
+ neq2.insert(1,1,'\0');
+ neq3.insert(1,1,'\0');
+
+ CPPUNIT_CNCEQ_ASSERT( s1, eq );
+ CPPUNIT_CNCEQ_ASSERT( s1, eq2 );
+ CPPUNIT_CNCEQ_ASSERT( s1, eq3 );
+
+ CPPUNIT_CNCNEQ_ASSERT( s1, neq );
+ CPPUNIT_CNCNEQ_ASSERT( s1, neq2 );
+ CPPUNIT_CNCNEQ_ASSERT( s1, neq3 );
+}
+
+void StringTestCase::Contains()
+{
+ static const struct ContainsData
+ {
+ const wxChar *hay;
+ const wxChar *needle;
+ bool contains;
+ } containsData[] =
+ {
+ { wxT(""), wxT(""), true },
+ { wxT(""), wxT("foo"), false },
+ { wxT("foo"), wxT(""), true },
+ { wxT("foo"), wxT("f"), true },
+ { wxT("foo"), wxT("o"), true },
+ { wxT("foo"), wxT("oo"), true },
+ { wxT("foo"), wxT("ooo"), false },
+ { wxT("foo"), wxT("oooo"), false },
+ { wxT("foo"), wxT("fooo"), false },
+ };
+
+ for ( size_t n = 0; n < WXSIZEOF(containsData); n++ )
+ {
+ const ContainsData& cd = containsData[n];
+ CPPUNIT_ASSERT_EQUAL( cd.contains, wxString(cd.hay).Contains(cd.needle) );
+ }
+}
+
+// flags used in ToLongData.flags
+enum
+{
+ Number_Ok = 0,
+ Number_Invalid = 1,
+ Number_Unsigned = 2, // if not specified, works for signed conversion
+ Number_Signed = 4, // if not specified, works for unsigned
+ Number_LongLong = 8, // only for long long tests
+ Number_Long = 16 // only for long tests
+};
+
+static const struct ToLongData
+{
+ const wxChar *str;
+#ifdef wxLongLong_t
+ wxLongLong_t value;
+#else
+ long value;
+#endif // wxLongLong_t
+ int flags;
+
+ long LValue() const { return value; }
+ unsigned long ULValue() const { return value; }
+#ifdef wxLongLong_t
+ wxLongLong_t LLValue() const { return value; }
+ wxULongLong_t ULLValue() const { return (wxULongLong_t)value; }
+#endif // wxLongLong_t
+
+ bool IsOk() const { return !(flags & Number_Invalid); }
+} longData[] =
+{
+ { wxT("1"), 1, Number_Ok },
+ { wxT("0"), 0, Number_Ok },
+ { wxT("a"), 0, Number_Invalid },
+ { wxT("12345"), 12345, Number_Ok },
+ { wxT("--1"), 0, Number_Invalid },
+
+ { wxT("-1"), -1, Number_Signed | Number_Long },
+ // this is surprizing but consistent with strtoul() behaviour
+ { wxT("-1"), ULONG_MAX, Number_Unsigned | Number_Long },
+
+ // this must overflow, even with 64 bit long
+ { wxT("922337203685477580711"), 0, Number_Invalid },
+
+#ifdef wxLongLong_t
+ { wxT("2147483648"), wxLL(2147483648), Number_LongLong },
+ { wxT("-2147483648"), wxLL(-2147483648), Number_LongLong | Number_Signed },
+ { wxT("9223372036854775808"), wxULL(9223372036854775808), Number_LongLong |
+ Number_Unsigned },
+#endif // wxLongLong_t
+};
+
+void StringTestCase::ToLong()
+{
+ long l;
+ for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+ {
+ const ToLongData& ld = longData[n];
+
+ if ( ld.flags & (Number_LongLong | Number_Unsigned) )
+ continue;
+
+ // NOTE: unless you're using some exotic locale, ToCLong and ToLong
+ // should behave the same for our test data set:
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToCLong(&l) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.LValue(), l );
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLong(&l) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.LValue(), l );
+ }
+
+ // special case: check that the output is not modified if the parsing
+ // failed completely
+ l = 17;
+ CPPUNIT_ASSERT( !wxString("foo").ToLong(&l) );
+ CPPUNIT_ASSERT_EQUAL( 17, l );
+
+ // also check that it is modified if we did parse something successfully in
+ // the beginning of the string
+ CPPUNIT_ASSERT( !wxString("9 cats").ToLong(&l) );
+ CPPUNIT_ASSERT_EQUAL( 9, l );
+}
+
+void StringTestCase::ToULong()
+{
+ unsigned long ul;
+ for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+ {
+ const ToLongData& ld = longData[n];
+
+ if ( ld.flags & (Number_LongLong | Number_Signed) )
+ continue;
+
+ // NOTE: unless you're using some exotic locale, ToCLong and ToLong
+ // should behave the same for our test data set:
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToCULong(&ul) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.ULValue(), ul );
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULong(&ul) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.ULValue(), ul );
+ }
+}
+
+#ifdef wxLongLong_t
+
+void StringTestCase::ToLongLong()
+{
+ wxLongLong_t l;
+ for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+ {
+ const ToLongData& ld = longData[n];
+
+ if ( ld.flags & (Number_Long | Number_Unsigned) )
+ continue;
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLongLong(&l) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.LLValue(), l );
+ }
+}
+
+void StringTestCase::ToULongLong()
+{
+ wxULongLong_t ul;
+ for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+ {
+ const ToLongData& ld = longData[n];
+
+ if ( ld.flags & (Number_Long | Number_Signed) )
+ continue;
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULongLong(&ul) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.ULLValue(), ul );
+ }
+}
+
+#endif // wxLongLong_t
+
+void StringTestCase::ToDouble()
+{
+ double d;
+ static const struct ToDoubleData
+ {
+ const wxChar *str;
+ double value;
+ bool ok;
+ } doubleData[] =
+ {
+ { wxT("1"), 1, true },
+ { wxT("1.23"), 1.23, true },
+ { wxT(".1"), .1, true },
+ { wxT("1."), 1, true },
+ { wxT("1.."), 0, false },
+ { wxT("0"), 0, true },
+ { wxT("a"), 0, false },
+ { wxT("12345"), 12345, true },
+ { wxT("-1"), -1, true },
+ { wxT("--1"), 0, false },
+ { wxT("-3E-5"), -3E-5, true },
+ { wxT("-3E-abcde5"), 0, false },
+ };
+
+ // test ToCDouble() first:
+
+ size_t n;
+ for ( n = 0; n < WXSIZEOF(doubleData); n++ )
+ {
+ const ToDoubleData& ld = doubleData[n];
+ CPPUNIT_ASSERT_EQUAL( ld.ok, wxString(ld.str).ToCDouble(&d) );
+ if ( ld.ok )
+ CPPUNIT_ASSERT_EQUAL( ld.value, d );
+ }
+
+
+ // test ToDouble() now:
+ // NOTE: for the test to be reliable, we need to set the locale explicitely
+ // so that we know the decimal point character to use
+
+ if (!wxLocale::IsAvailable(wxLANGUAGE_FRENCH))
+ return; // you should have french support installed to continue this test!
+
+ wxLocale *locale = new wxLocale;
+
+ // don't load default catalog, it may be unavailable:
+ CPPUNIT_ASSERT( locale->Init(wxLANGUAGE_FRENCH, wxLOCALE_CONV_ENCODING) );
+
+ static const struct ToDoubleData doubleData2[] =
+ {
+ { wxT("1"), 1, true },
+ { wxT("1,23"), 1.23, true },
+ { wxT(",1"), .1, true },
+ { wxT("1,"), 1, true },
+ { wxT("1,,"), 0, false },
+ { wxT("0"), 0, true },
+ { wxT("a"), 0, false },
+ { wxT("12345"), 12345, true },
+ { wxT("-1"), -1, true },
+ { wxT("--1"), 0, false },
+ { wxT("-3E-5"), -3E-5, true },
+ { wxT("-3E-abcde5"), 0, false },
+ };
+
+ for ( n = 0; n < WXSIZEOF(doubleData2); n++ )
+ {
+ const ToDoubleData& ld = doubleData2[n];
+ CPPUNIT_ASSERT_EQUAL( ld.ok, wxString(ld.str).ToDouble(&d) );
+ if ( ld.ok )
+ CPPUNIT_ASSERT_EQUAL( ld.value, d );
+ }
+
+ delete locale;
+}
+
+void StringTestCase::StringBuf()
+{
+ // check that buffer can be used to write into the string
+ wxString s;
+ wxStrcpy(wxStringBuffer(s, 10), wxT("foo"));
+
+ CPPUNIT_ASSERT_EQUAL(3, s.length());
+ CPPUNIT_ASSERT(wxT('f') == s[0u]);
+ CPPUNIT_ASSERT(wxT('o') == s[1]);
+ CPPUNIT_ASSERT(wxT('o') == s[2]);
projects / wxWidgets.git / blobdiff