1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: tests/strings/unicode.cpp
3 // Purpose: Unicode unit test
4 // Author: Vadim Zeitlin, Wlodzimierz ABX Skiba
7 // Copyright: (c) 2004 Vadim Zeitlin, Wlodzimierz Skiba
8 ///////////////////////////////////////////////////////////////////////////////
10 // ----------------------------------------------------------------------------
12 // ----------------------------------------------------------------------------
24 // ----------------------------------------------------------------------------
26 // ----------------------------------------------------------------------------
28 #if wxUSE_WCHAR_T && !wxUSE_UNICODE
30 // in case wcscmp is missing
31 static int wx_wcscmp(const wchar_t *s1
, const wchar_t *s2
)
33 while (*s1
== *s2
&& *s1
!= 0)
41 #endif // wxUSE_WCHAR_T && !wxUSE_UNICODE
43 // ----------------------------------------------------------------------------
45 // ----------------------------------------------------------------------------
47 class UnicodeTestCase
: public CppUnit::TestCase
53 CPPUNIT_TEST_SUITE( UnicodeTestCase
);
54 CPPUNIT_TEST( ToFromAscii
);
56 CPPUNIT_TEST( ConstructorsWithConversion
);
57 CPPUNIT_TEST( ConversionEmpty
);
58 CPPUNIT_TEST( ConversionWithNULs
);
59 CPPUNIT_TEST( ConversionUTF7
);
60 CPPUNIT_TEST( ConversionUTF8
);
61 CPPUNIT_TEST( ConversionUTF16
);
62 CPPUNIT_TEST( ConversionUTF32
);
63 CPPUNIT_TEST( IsConvOk
);
64 #endif // wxUSE_WCHAR_T
66 CPPUNIT_TEST( Iteration
);
68 CPPUNIT_TEST_SUITE_END();
72 void ConstructorsWithConversion();
73 void ConversionEmpty();
74 void ConversionWithNULs();
75 void ConversionUTF7();
76 void ConversionUTF8();
77 void ConversionUTF16();
78 void ConversionUTF32();
84 // test if converting s using the given encoding gives ws and vice versa
86 // if either of the first 2 arguments is NULL, the conversion is supposed
88 void DoTestConversion(const char *s
, const wchar_t *w
, wxMBConv
& conv
);
89 #endif // wxUSE_WCHAR_T
92 DECLARE_NO_COPY_CLASS(UnicodeTestCase
)
95 // register in the unnamed registry so that these tests are run by default
96 CPPUNIT_TEST_SUITE_REGISTRATION( UnicodeTestCase
);
98 // also include in it's own registry so that these tests can be run alone
99 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( UnicodeTestCase
, "UnicodeTestCase" );
101 UnicodeTestCase::UnicodeTestCase()
105 void UnicodeTestCase::ToFromAscii()
108 #define TEST_TO_FROM_ASCII(txt) \
110 static const char *msg = txt; \
111 wxString s = wxString::FromAscii(msg); \
112 CPPUNIT_ASSERT( strcmp( s.ToAscii() , msg ) == 0 ); \
115 TEST_TO_FROM_ASCII( "Hello, world!" );
116 TEST_TO_FROM_ASCII( "additional \" special \t test \\ component \n :-)" );
120 void UnicodeTestCase::ConstructorsWithConversion()
122 // the string "Déjà" in UTF-8 and wchar_t:
123 const unsigned char utf8Buf
[] = {0x44,0xC3,0xA9,0x6A,0xC3,0xA0,0};
124 const wchar_t wchar
[] = {0x44,0xE9,0x6A,0xE0,0};
125 const unsigned char utf8subBuf
[] = {0x44,0xC3,0xA9,0x6A,0}; // just "Déj"
126 const char *utf8
= (char *)utf8Buf
;
127 const char *utf8sub
= (char *)utf8subBuf
;
129 wxString
s1(utf8
, wxConvUTF8
);
130 wxString
s2(wchar
, wxConvUTF8
);
133 WX_ASSERT_STR_EQUAL( wchar
, s1
);
134 WX_ASSERT_STR_EQUAL( wchar
, s2
);
136 WX_ASSERT_STR_EQUAL( utf8
, s1
);
137 WX_ASSERT_STR_EQUAL( utf8
, s2
);
140 wxString
sub(utf8sub
, wxConvUTF8
); // "Dej" substring
141 wxString
s3(utf8
, wxConvUTF8
, 4);
142 wxString
s4(wchar
, wxConvUTF8
, 3);
144 CPPUNIT_ASSERT_EQUAL( sub
, s3
);
145 CPPUNIT_ASSERT_EQUAL( sub
, s4
);
148 // conversion should stop with failure at pos 35
149 wxString
s("\t[pl]open.format.Sformatuj dyskietkê=gfloppy %f", wxConvUTF8
);
150 CPPUNIT_ASSERT( s
.empty() );
154 // test using Unicode strings together with char* strings (this must work
155 // in ANSI mode as well, of course):
156 wxString
s5("ascii");
157 WX_ASSERT_STR_EQUAL( "ascii", s5
);
161 CPPUNIT_ASSERT( strcmp(s5
.mb_str(), "ascii value") == 0 );
162 WX_ASSERT_STR_EQUAL( "ascii value", s5
);
163 CPPUNIT_ASSERT( s5
!= "SomethingElse" );
166 void UnicodeTestCase::ConversionEmpty()
171 wxCharBuffer buf
= wxConvLibc
.cWC2MB(L
"", 0, &len
);
172 #else // !wxUSE_UNICODE
173 wxWCharBuffer wbuf
= wxConvLibc
.cMB2WC("", 0, &len
);
174 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
176 CPPUNIT_ASSERT(len
== 0);
179 void UnicodeTestCase::ConversionWithNULs()
182 static const size_t lenNulString
= 10;
184 wxString
szTheString(L
"The\0String", wxConvLibc
, lenNulString
);
185 wxCharBuffer theBuffer
= szTheString
.mb_str();
187 CPPUNIT_ASSERT( memcmp(theBuffer
.data(), "The\0String",
188 lenNulString
+ 1) == 0 );
190 wxString
szTheString2("The\0String", wxConvLocal
, lenNulString
);
191 CPPUNIT_ASSERT_EQUAL( lenNulString
, szTheString2
.length() );
192 CPPUNIT_ASSERT( wxTmemcmp(szTheString2
.c_str(), L
"The\0String",
193 lenNulString
+ 1) == 0 );
194 #else // !wxUSE_UNICODE
195 wxString
szTheString(wxT("TheString"));
196 szTheString
.insert(3, 1, '\0');
197 wxWCharBuffer theBuffer
= szTheString
.wc_str(wxConvLibc
);
199 CPPUNIT_ASSERT( memcmp(theBuffer
.data(), L
"The\0String", 11 * sizeof(wchar_t)) == 0 );
201 wxString
szLocalTheString(wxT("TheString"));
202 szLocalTheString
.insert(3, 1, '\0');
203 wxWCharBuffer theLocalBuffer
= szLocalTheString
.wc_str(wxConvLocal
);
205 CPPUNIT_ASSERT( memcmp(theLocalBuffer
.data(), L
"The\0String", 11 * sizeof(wchar_t)) == 0 );
206 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
210 UnicodeTestCase::DoTestConversion(const char *s
,
217 wxCharBuffer buf
= conv
.cWC2MB(ws
, (size_t)-1, NULL
);
219 CPPUNIT_ASSERT( strcmp(buf
, s
) == 0 );
221 #else // wxUSE_UNICODE
224 wxWCharBuffer wbuf
= conv
.cMB2WC(s
, (size_t)-1, NULL
);
228 CPPUNIT_ASSERT( wbuf
.data() );
229 CPPUNIT_ASSERT( wx_wcscmp(wbuf
, ws
) == 0 );
231 else // conversion is supposed to fail
233 CPPUNIT_ASSERT_EQUAL( (wchar_t *)NULL
, wbuf
.data() );
236 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
239 struct StringConversionData
245 void UnicodeTestCase::ConversionUTF7()
247 static const StringConversionData utf7data
[] =
252 #ifdef wxHAVE_U_ESCAPE
253 { "+AKM-", L
"\u00a3" },
254 #endif // wxHAVE_U_ESCAPE
256 // the following are invalid UTF-7 sequences
262 wxCSConv
conv(_T("utf-7"));
263 for ( size_t n
= 0; n
< WXSIZEOF(utf7data
); n
++ )
265 const StringConversionData
& d
= utf7data
[n
];
267 // converting to/from UTF-7 using iconv() currently doesn't work
268 // because of several problems:
269 // - GetMBNulLen() doesn't return correct result (iconv converts L'\0'
270 // to an incomplete and anyhow nonsensical "+AA" string)
271 // - iconv refuses to convert "+-" (although it converts "+-\n" just
274 // I have no idea how to fix this so just disable the test for now
276 DoTestConversion(d
.str
, d
.wcs
, conv
);
278 DoTestConversion(d
.str
, d
.wcs
, wxConvUTF7
);
282 void UnicodeTestCase::ConversionUTF8()
284 static const StringConversionData utf8data
[] =
286 #ifdef wxHAVE_U_ESCAPE
287 { "\xc2\xa3", L
"\u00a3" },
292 wxCSConv
conv(_T("utf-8"));
293 for ( size_t n
= 0; n
< WXSIZEOF(utf8data
); n
++ )
295 const StringConversionData
& d
= utf8data
[n
];
296 DoTestConversion(d
.str
, d
.wcs
, conv
);
297 DoTestConversion(d
.str
, d
.wcs
, wxConvUTF8
);
301 void UnicodeTestCase::ConversionUTF16()
303 static const StringConversionData utf16data
[] =
305 #ifdef wxHAVE_U_ESCAPE
306 { "\x04\x1f\x04\x40\x04\x38\x04\x32\x04\x35\x04\x42\0\0",
307 L
"\u041f\u0440\u0438\u0432\u0435\u0442" },
308 { "\x01\0\0b\x01\0\0a\x01\0\0r\0\0", L
"\u0100b\u0100a\u0100r" },
310 { "\0f\0o\0o\0\0", L
"foo" },
313 wxCSConv
conv(wxFONTENCODING_UTF16BE
);
314 for ( size_t n
= 0; n
< WXSIZEOF(utf16data
); n
++ )
316 const StringConversionData
& d
= utf16data
[n
];
317 DoTestConversion(d
.str
, d
.wcs
, conv
);
320 // special case: this string has consecutive NULs inside it which don't
321 // terminate the string, this exposed a bug in our conversion code which
322 // got confused in this case
324 wxWCharBuffer
wbuf(conv
.cMB2WC("\x01\0\0B\0C" /* A macron BC */, 6, &len
));
325 CPPUNIT_ASSERT_EQUAL( (size_t)3, len
);
328 void UnicodeTestCase::ConversionUTF32()
330 static const StringConversionData utf32data
[] =
332 #ifdef wxHAVE_U_ESCAPE
334 "\0\0\x04\x1f\0\0\x04\x40\0\0\x04\x38\0\0\x04\x32\0\0\x04\x35\0\0\x04\x42\0\0\0\0",
335 L
"\u041f\u0440\u0438\u0432\u0435\u0442" },
337 { "\0\0\0f\0\0\0o\0\0\0o\0\0\0\0", L
"foo" },
340 wxCSConv
conv(wxFONTENCODING_UTF32BE
);
341 for ( size_t n
= 0; n
< WXSIZEOF(utf32data
); n
++ )
343 const StringConversionData
& d
= utf32data
[n
];
344 DoTestConversion(d
.str
, d
.wcs
, conv
);
348 wxWCharBuffer
wbuf(conv
.cMB2WC("\0\0\x01\0\0\0\0B\0\0\0C" /* A macron BC */,
350 CPPUNIT_ASSERT_EQUAL( (size_t)3, len
);
353 void UnicodeTestCase::IsConvOk()
355 CPPUNIT_ASSERT( wxCSConv(wxFONTENCODING_SYSTEM
).IsOk() );
356 CPPUNIT_ASSERT( wxCSConv(_T("UTF-8")).IsOk() );
357 CPPUNIT_ASSERT( !wxCSConv(_T("NoSuchConversion")).IsOk() );
360 CPPUNIT_ASSERT( wxCSConv(_T("WINDOWS-437")).IsOk() );
364 #endif // wxUSE_WCHAR_T
367 void UnicodeTestCase::Iteration()
369 // "czech" in Czech ("cestina"):
370 static const char *textUTF8
= "\304\215e\305\241tina";
371 static const wchar_t textUTF16
[] = {0x10D, 0x65, 0x161, 0x74, 0x69, 0x6E, 0x61, 0};
373 wxString
text(wxString::FromUTF8(textUTF8
));
374 CPPUNIT_ASSERT( wxStrcmp(text
.wc_str(), textUTF16
) == 0 );
376 // verify the string was decoded correctly:
379 for ( wxString::const_iterator i
= text
.begin(); i
!= text
.end(); ++i
, ++idx
)
381 CPPUNIT_ASSERT( *i
== textUTF16
[idx
] );
385 // overwrite the string with something that is shorter in UTF-8:
387 for ( wxString::iterator i
= text
.begin(); i
!= text
.end(); ++i
)
391 // restore the original text now:
393 wxString::iterator end1
= text
.end();
394 wxString::const_iterator end2
= text
.end();
397 for ( wxString::iterator i
= text
.begin(); i
!= text
.end(); ++i
, ++idx
)
401 CPPUNIT_ASSERT( end1
== text
.end() );
402 CPPUNIT_ASSERT( end2
== text
.end() );
405 CPPUNIT_ASSERT( end1
== text
.end() );
406 CPPUNIT_ASSERT( end2
== text
.end() );
409 // and verify it again:
412 for ( wxString::const_iterator i
= text
.begin(); i
!= text
.end(); ++i
, ++idx
)
414 CPPUNIT_ASSERT( *i
== textUTF16
[idx
] );
418 #endif // wxUSE_UNICODE