+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, ld.base) );
+ if ( ld.IsOk() )
+ CPPUNIT_ASSERT_EQUAL( ld.ULValue(), ul );
+
+ CPPUNIT_ASSERT_EQUAL( ld.IsOk(),
+ wxString(ld.str).ToULong(&ul, ld.base) );
+ 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, ld.base) );
+ 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, ld.base) );
+ 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 explicitly
+ // 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;
+
+ // don't load default catalog, it may be unavailable:
+ CPPUNIT_ASSERT( locale.Init(wxLANGUAGE_FRENCH, wxLOCALE_DONT_LOAD_DEFAULT) );
+
+ 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 );
+ }
+}
+
+void StringTestCase::FromDouble()
+{
+ static const struct FromDoubleTestData
+ {
+ double value;
+ int prec;
+ const char *str;
+ } testData[] =
+ {
+ { 1.23, -1, "1.23" },
+ // NB: there are no standards about the minimum exponent width
+ // and newer MSVC versions use 3 digits as minimum exponent
+ // width while GNU libc uses 2 digits as minimum width...
+#ifdef wxUSING_VC_CRT_IO
+ { -3e-10, -1, "-3e-010" },
+#else
+ { -3e-10, -1, "-3e-10" },
+#endif
+ { -0.45678, -1, "-0.45678" },
+ { 1.2345678, 0, "1" },
+ { 1.2345678, 1, "1.2" },
+ { 1.2345678, 2, "1.23" },
+ { 1.2345678, 3, "1.235" },
+ };
+
+ for ( unsigned n = 0; n < WXSIZEOF(testData); n++ )
+ {
+ const FromDoubleTestData& td = testData[n];
+ CPPUNIT_ASSERT_EQUAL( td.str, wxString::FromCDouble(td.value, td.prec) );
+ }
+
+ if ( !wxLocale::IsAvailable(wxLANGUAGE_FRENCH) )
+ return;
+
+ wxLocale locale;
+ CPPUNIT_ASSERT( locale.Init(wxLANGUAGE_FRENCH, wxLOCALE_DONT_LOAD_DEFAULT) );
+
+ for ( unsigned m = 0; m < WXSIZEOF(testData); m++ )
+ {
+ const FromDoubleTestData& td = testData[m];
+
+ wxString str(td.str);
+ str.Replace(".", ",");
+ CPPUNIT_ASSERT_EQUAL( str, wxString::FromDouble(td.value, td.prec) );
+ }
+}
+
+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]);
+
+ {
+ // also check that the buffer initially contains the original string
+ // contents
+ wxStringBuffer buf(s, 10);
+ CPPUNIT_ASSERT_EQUAL( wxT('f'), buf[0] );
+ CPPUNIT_ASSERT_EQUAL( wxT('o'), buf[1] );
+ CPPUNIT_ASSERT_EQUAL( wxT('o'), buf[2] );
+ CPPUNIT_ASSERT_EQUAL( wxT('\0'), buf[3] );
+ }
+
+ {
+ wxStringBufferLength buf(s, 10);
+ CPPUNIT_ASSERT_EQUAL( wxT('f'), buf[0] );
+ CPPUNIT_ASSERT_EQUAL( wxT('o'), buf[1] );
+ CPPUNIT_ASSERT_EQUAL( wxT('o'), buf[2] );
+ CPPUNIT_ASSERT_EQUAL( wxT('\0'), buf[3] );
+
+ // and check that it can be used to write only the specified number of
+ // characters to the string
+ wxStrcpy(buf, wxT("barrbaz"));
+ buf.SetLength(4);
+ }
+
+ CPPUNIT_ASSERT_EQUAL(4, s.length());
+ CPPUNIT_ASSERT(wxT('b') == s[0u]);
+ CPPUNIT_ASSERT(wxT('a') == s[1]);
+ CPPUNIT_ASSERT(wxT('r') == s[2]);
+ CPPUNIT_ASSERT(wxT('r') == s[3]);
+
+ // check that creating buffer of length smaller than string works, i.e. at
+ // least doesn't crash (it would if we naively copied the entire original
+ // string contents in the buffer)
+ *wxStringBuffer(s, 1) = '!';
+}
+
+void StringTestCase::UTF8Buf()
+{
+#if wxUSE_UNICODE
+ // "czech" in Czech ("cestina"):
+ static const char *textUTF8 = "\304\215e\305\241tina";
+ static const wchar_t textUTF16[] = {0x10D, 0x65, 0x161, 0x74, 0x69, 0x6E, 0x61, 0};
+
+ wxString s;
+ wxStrcpy(wxUTF8StringBuffer(s, 9), textUTF8);
+ CPPUNIT_ASSERT(s == textUTF16);
+
+ {
+ wxUTF8StringBufferLength buf(s, 20);
+ wxStrcpy(buf, textUTF8);
+ buf.SetLength(5);
+ }
+ CPPUNIT_ASSERT(s == wxString(textUTF16, 0, 3));
+#endif // wxUSE_UNICODE
+}
+
+
+
+void StringTestCase::CStrDataTernaryOperator()
+{
+ DoCStrDataTernaryOperator(true);
+ DoCStrDataTernaryOperator(false);
+}
+
+template<typename T> bool CheckStr(const wxString& expected, T s)
+{
+ return expected == wxString(s);
+}
+
+void StringTestCase::DoCStrDataTernaryOperator(bool cond)
+{
+ // test compilation of wxCStrData when used with operator?: (the asserts
+ // are not very important, we're testing if the code compiles at all):
+
+ wxString s("foo");
+
+ const wchar_t *wcStr = L"foo";
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : wcStr)) );
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : L"foo")) );
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? wcStr : s.c_str())) );
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? L"foo" : s.c_str())) );
+
+ const char *mbStr = "foo";
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : mbStr)) );
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : "foo")) );
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? mbStr : s.c_str())) );
+ CPPUNIT_ASSERT( CheckStr(s, (cond ? "foo" : s.c_str())) );
+
+ wxString empty("");
+ CPPUNIT_ASSERT( CheckStr(empty, (cond ? empty.c_str() : wxEmptyString)) );
+ CPPUNIT_ASSERT( CheckStr(empty, (cond ? wxEmptyString : empty.c_str())) );
+}
+
+void StringTestCase::CStrDataOperators()
+{
+ wxString s("hello");
+
+ CPPUNIT_ASSERT( s.c_str()[0] == 'h' );
+ CPPUNIT_ASSERT( s.c_str()[1] == 'e' );
+
+ // IMPORTANT: at least with the CRT coming with MSVC++ 2008 trying to access
+ // the final character results in an assert failure (with debug CRT)
+ //CPPUNIT_ASSERT( s.c_str()[5] == '\0' );
+
+ CPPUNIT_ASSERT( *s.c_str() == 'h' );
+ CPPUNIT_ASSERT( *(s.c_str() + 2) == 'l' );
+ //CPPUNIT_ASSERT( *(s.c_str() + 5) == '\0' );
+}
+
+bool CheckStrChar(const wxString& expected, char *s)
+ { return CheckStr(expected, s); }
+bool CheckStrWChar(const wxString& expected, wchar_t *s)
+ { return CheckStr(expected, s); }
+bool CheckStrConstChar(const wxString& expected, const char *s)
+ { return CheckStr(expected, s); }
+bool CheckStrConstWChar(const wxString& expected, const wchar_t *s)
+ { return CheckStr(expected, s); }
+
+void StringTestCase::CStrDataImplicitConversion()
+{
+ wxString s("foo");
+
+ CPPUNIT_ASSERT( CheckStrConstWChar(s, s.c_str()) );
+ CPPUNIT_ASSERT( CheckStrConstChar(s, s.c_str()) );
+
+ // implicit conversion of wxString is not available in STL build
+#if !wxUSE_STL
+ CPPUNIT_ASSERT( CheckStrConstWChar(s, s) );
+ CPPUNIT_ASSERT( CheckStrConstChar(s, s) );
+#endif
+}
+
+void StringTestCase::ExplicitConversion()
+{
+ wxString s("foo");
+
+ CPPUNIT_ASSERT( CheckStr(s, s.mb_str()) );
+ CPPUNIT_ASSERT( CheckStrConstChar(s, s.mb_str()) );
+ CPPUNIT_ASSERT( CheckStrChar(s, s.char_str()) );
+
+ CPPUNIT_ASSERT( CheckStr(s, s.wc_str()) );
+ CPPUNIT_ASSERT( CheckStrConstWChar(s, s.wc_str()) );
+ CPPUNIT_ASSERT( CheckStrWChar(s, s.wchar_str()) );
+}
+
+void StringTestCase::IndexedAccess()
+{
+ wxString s("bar");
+ CPPUNIT_ASSERT_EQUAL( 'r', (char)s[2] );
+
+ // this tests for a possible bug in UTF-8 based wxString implementation:
+ // the 3rd character of the underlying byte string is going to change, but
+ // the 3rd character of wxString should remain the same
+ s[0] = L'\xe9';
+ CPPUNIT_ASSERT_EQUAL( 'r', (char)s[2] );
+}
+
+void StringTestCase::BeforeAndAfter()
+{
+ // Construct a string with 2 equal signs in it by concatenating its three
+ // parts: before the first "=", in between the two "="s and after the last
+ // one. This allows to avoid duplicating the string contents (which has to
+ // be different for Unicode and ANSI builds) in the tests below.
+#if wxUSE_UNICODE
+ #define FIRST_PART L"letter"
+ #define MIDDLE_PART L"\xe9;\xe7a"
+ #define LAST_PART L"l\xe0"
+#else // !wxUSE_UNICODE
+ #define FIRST_PART "letter"
+ #define MIDDLE_PART "e;ca"
+ #define LAST_PART "la"
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE
+
+ const wxString s(FIRST_PART wxT("=") MIDDLE_PART wxT("=") LAST_PART);
+
+ wxString r;
+
+ CPPUNIT_ASSERT_EQUAL( FIRST_PART, s.BeforeFirst('=', &r) );
+ CPPUNIT_ASSERT_EQUAL( MIDDLE_PART wxT("=") LAST_PART, r );
+
+ CPPUNIT_ASSERT_EQUAL( s, s.BeforeFirst('!', &r) );
+ CPPUNIT_ASSERT_EQUAL( "", r );
+
+
+ CPPUNIT_ASSERT_EQUAL( FIRST_PART wxT("=") MIDDLE_PART, s.BeforeLast('=', &r) );
+ CPPUNIT_ASSERT_EQUAL( LAST_PART, r );
+
+ CPPUNIT_ASSERT_EQUAL( "", s.BeforeLast('!', &r) );
+ CPPUNIT_ASSERT_EQUAL( s, r );
+
+
+ CPPUNIT_ASSERT_EQUAL( MIDDLE_PART wxT("=") LAST_PART, s.AfterFirst('=') );
+ CPPUNIT_ASSERT_EQUAL( "", s.AfterFirst('!') );
+
+
+ CPPUNIT_ASSERT_EQUAL( LAST_PART, s.AfterLast('=') );
+ CPPUNIT_ASSERT_EQUAL( s, s.AfterLast('!') );
+
+ #undef LAST_PART
+ #undef MIDDLE_PART
+ #undef FIRST_PART
+}
+
+void StringTestCase::ScopedBuffers()
+{
+ // wxString relies on efficient buffers, verify they work as they should
+
+ const char *literal = "Hello World!";
+
+ // non-owned buffer points to the string passed to it
+ wxScopedCharBuffer sbuf = wxScopedCharBuffer::CreateNonOwned(literal);
+ CPPUNIT_ASSERT( sbuf.data() == literal );
+
+ // a copy of scoped non-owned buffer still points to the same string
+ wxScopedCharBuffer sbuf2(sbuf);
+ CPPUNIT_ASSERT( sbuf.data() == sbuf2.data() );
+
+ // but assigning it to wxCharBuffer makes a full copy
+ wxCharBuffer buf(sbuf);
+ CPPUNIT_ASSERT( buf.data() != literal );
+ CPPUNIT_ASSERT_EQUAL( literal, buf.data() );
+
+ wxCharBuffer buf2 = sbuf;
+ CPPUNIT_ASSERT( buf2.data() != literal );
+ CPPUNIT_ASSERT_EQUAL( literal, buf.data() );
+
+ // Check that extending the buffer keeps it NUL-terminated.
+ size_t len = 10;
+
+ wxCharBuffer buf3(len);
+ CPPUNIT_ASSERT_EQUAL('\0', buf3.data()[len]);
+
+ wxCharBuffer buf4;
+ buf4.extend(len);
+ CPPUNIT_ASSERT_EQUAL('\0', buf4.data()[len]);
+
+ wxCharBuffer buf5(5);
+ buf5.extend(len);
+ CPPUNIT_ASSERT_EQUAL('\0', buf5.data()[len]);
+}
projects / wxWidgets.git / blobdiff