]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: tests/strings/unicode.cpp | |
3 | // Purpose: Unicode unit test | |
4 | // Author: Vadim Zeitlin, Wlodzimierz ABX Skiba | |
5 | // Created: 2004-04-28 | |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) 2004 Vadim Zeitlin, Wlodzimierz Skiba | |
8 | /////////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | // ---------------------------------------------------------------------------- | |
11 | // headers | |
12 | // ---------------------------------------------------------------------------- | |
13 | ||
14 | #include "testprec.h" | |
15 | ||
16 | #ifdef __BORLANDC__ | |
17 | #pragma hdrstop | |
18 | #endif | |
19 | ||
20 | #ifndef WX_PRECOMP | |
21 | #include "wx/wx.h" | |
22 | #endif // WX_PRECOMP | |
23 | ||
24 | #include "wx/encconv.h" | |
25 | ||
26 | // ---------------------------------------------------------------------------- | |
27 | // helper class holding the matching MB and WC strings | |
28 | // ---------------------------------------------------------------------------- | |
29 | ||
30 | struct StringConversionData | |
31 | { | |
32 | // either str or wcs (but not both) may be NULL, this means that the conversion | |
33 | // to it should fail | |
34 | StringConversionData(const char *str_, const wchar_t *wcs_, int flags_ = 0) | |
35 | : str(str_), wcs(wcs_), flags(flags_) | |
36 | { | |
37 | } | |
38 | ||
39 | const char * const str; | |
40 | const wchar_t * const wcs; | |
41 | ||
42 | enum | |
43 | { | |
44 | TEST_BOTH = 0, // test both str -> wcs and wcs -> str | |
45 | ONLY_MB2WC = 1 // only test str -> wcs conversion | |
46 | }; | |
47 | ||
48 | const int flags; | |
49 | ||
50 | // test that the conversion between str and wcs (subject to flags) succeeds | |
51 | // | |
52 | // the first argument is the index in the test array and is used solely for | |
53 | // diagnostics | |
54 | void Test(size_t n, wxMBConv& conv) const | |
55 | { | |
56 | if ( str ) | |
57 | { | |
58 | wxWCharBuffer wbuf = conv.cMB2WC(str); | |
59 | ||
60 | if ( wcs ) | |
61 | { | |
62 | CPPUNIT_ASSERT_MESSAGE | |
63 | ( | |
64 | Message(n, "MB2WC failed"), | |
65 | wbuf.data() | |
66 | ); | |
67 | ||
68 | CPPUNIT_ASSERT_MESSAGE | |
69 | ( | |
70 | Message(n, "MB2WC", wbuf, wcs), | |
71 | wxStrcmp(wbuf, wcs) == 0 | |
72 | ); | |
73 | } | |
74 | else // conversion is supposed to fail | |
75 | { | |
76 | CPPUNIT_ASSERT_MESSAGE | |
77 | ( | |
78 | Message(n, "MB2WC succeeded"), | |
79 | !wbuf.data() | |
80 | ); | |
81 | } | |
82 | } | |
83 | ||
84 | if ( wcs && !(flags & ONLY_MB2WC) ) | |
85 | { | |
86 | wxCharBuffer buf = conv.cWC2MB(wcs); | |
87 | ||
88 | if ( str ) | |
89 | { | |
90 | CPPUNIT_ASSERT_MESSAGE | |
91 | ( | |
92 | Message(n, "WC2MB failed"), | |
93 | buf.data() | |
94 | ); | |
95 | ||
96 | CPPUNIT_ASSERT_MESSAGE | |
97 | ( | |
98 | Message(n, "WC2MB", buf, str), | |
99 | strcmp(buf, str) == 0 | |
100 | ); | |
101 | } | |
102 | else | |
103 | { | |
104 | CPPUNIT_ASSERT_MESSAGE | |
105 | ( | |
106 | Message(n, "WC2MB succeeded"), | |
107 | !buf.data() | |
108 | ); | |
109 | } | |
110 | } | |
111 | } | |
112 | ||
113 | private: | |
114 | static std::string | |
115 | Message(size_t n, const wxString& msg) | |
116 | { | |
117 | return std::string(wxString::Format("#%lu: %s", (unsigned long)n, msg)); | |
118 | } | |
119 | ||
120 | template <typename T> | |
121 | static std::string | |
122 | Message(size_t n, | |
123 | const char *func, | |
124 | const wxCharTypeBuffer<T>& actual, | |
125 | const T *expected) | |
126 | { | |
127 | return Message(n, | |
128 | wxString::Format("%s returned \"%s\", expected \"%s\"", | |
129 | func, actual.data(), expected)); | |
130 | } | |
131 | }; | |
132 | ||
133 | // ---------------------------------------------------------------------------- | |
134 | // test class | |
135 | // ---------------------------------------------------------------------------- | |
136 | ||
137 | class UnicodeTestCase : public CppUnit::TestCase | |
138 | { | |
139 | public: | |
140 | UnicodeTestCase(); | |
141 | ||
142 | private: | |
143 | CPPUNIT_TEST_SUITE( UnicodeTestCase ); | |
144 | CPPUNIT_TEST( ToFromAscii ); | |
145 | CPPUNIT_TEST( ConstructorsWithConversion ); | |
146 | CPPUNIT_TEST( ConversionFixed ); | |
147 | CPPUNIT_TEST( ConversionWithNULs ); | |
148 | CPPUNIT_TEST( ConversionUTF7 ); | |
149 | CPPUNIT_TEST( ConversionUTF8 ); | |
150 | CPPUNIT_TEST( ConversionUTF16 ); | |
151 | CPPUNIT_TEST( ConversionUTF32 ); | |
152 | CPPUNIT_TEST( IsConvOk ); | |
153 | #if wxUSE_UNICODE | |
154 | CPPUNIT_TEST( Iteration ); | |
155 | #endif | |
156 | CPPUNIT_TEST_SUITE_END(); | |
157 | ||
158 | void ToFromAscii(); | |
159 | void ConstructorsWithConversion(); | |
160 | void ConversionFixed(); | |
161 | void ConversionWithNULs(); | |
162 | void ConversionUTF7(); | |
163 | void ConversionUTF8(); | |
164 | void ConversionUTF16(); | |
165 | void ConversionUTF32(); | |
166 | void IsConvOk(); | |
167 | #if wxUSE_UNICODE | |
168 | void Iteration(); | |
169 | #endif | |
170 | ||
171 | DECLARE_NO_COPY_CLASS(UnicodeTestCase) | |
172 | }; | |
173 | ||
174 | // register in the unnamed registry so that these tests are run by default | |
175 | CPPUNIT_TEST_SUITE_REGISTRATION( UnicodeTestCase ); | |
176 | ||
177 | // also include in it's own registry so that these tests can be run alone | |
178 | CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( UnicodeTestCase, "UnicodeTestCase" ); | |
179 | ||
180 | UnicodeTestCase::UnicodeTestCase() | |
181 | { | |
182 | } | |
183 | ||
184 | void UnicodeTestCase::ToFromAscii() | |
185 | { | |
186 | ||
187 | #define TEST_TO_FROM_ASCII(txt) \ | |
188 | { \ | |
189 | static const char *msg = txt; \ | |
190 | wxString s = wxString::FromAscii(msg); \ | |
191 | CPPUNIT_ASSERT( strcmp( s.ToAscii() , msg ) == 0 ); \ | |
192 | } | |
193 | ||
194 | TEST_TO_FROM_ASCII( "Hello, world!" ); | |
195 | TEST_TO_FROM_ASCII( "additional \" special \t test \\ component \n :-)" ); | |
196 | } | |
197 | ||
198 | void UnicodeTestCase::ConstructorsWithConversion() | |
199 | { | |
200 | // the string "Déjà" in UTF-8 and wchar_t: | |
201 | const unsigned char utf8Buf[] = {0x44,0xC3,0xA9,0x6A,0xC3,0xA0,0}; | |
202 | const unsigned char utf8subBuf[] = {0x44,0xC3,0xA9,0x6A,0}; // just "Déj" | |
203 | const char *utf8 = (char *)utf8Buf; | |
204 | const char *utf8sub = (char *)utf8subBuf; | |
205 | ||
206 | wxString s1(utf8, wxConvUTF8); | |
207 | ||
208 | #if wxUSE_UNICODE | |
209 | const wchar_t wchar[] = {0x44,0xE9,0x6A,0xE0,0}; | |
210 | CPPUNIT_ASSERT_EQUAL( wchar, s1 ); | |
211 | ||
212 | wxString s2(wchar); | |
213 | CPPUNIT_ASSERT_EQUAL( wchar, s2 ); | |
214 | CPPUNIT_ASSERT_EQUAL( wxString::FromUTF8(utf8), s2 ); | |
215 | #else | |
216 | CPPUNIT_ASSERT_EQUAL( utf8, s1 ); | |
217 | #endif | |
218 | ||
219 | wxString sub(utf8sub, wxConvUTF8); // "Dej" substring | |
220 | wxString s3(utf8, wxConvUTF8, 4); | |
221 | CPPUNIT_ASSERT_EQUAL( sub, s3 ); | |
222 | ||
223 | #if wxUSE_UNICODE | |
224 | wxString s4(wchar, wxConvUTF8, 3); | |
225 | CPPUNIT_ASSERT_EQUAL( sub, s4 ); | |
226 | ||
227 | // conversion should stop with failure at pos 35 | |
228 | wxString s("\t[pl]open.format.Sformatuj dyskietk\xea=gfloppy %f", wxConvUTF8); | |
229 | CPPUNIT_ASSERT( s.empty() ); | |
230 | #endif // wxUSE_UNICODE | |
231 | ||
232 | ||
233 | // test using Unicode strings together with char* strings (this must work | |
234 | // in ANSI mode as well, of course): | |
235 | wxString s5("ascii"); | |
236 | CPPUNIT_ASSERT_EQUAL( "ascii", s5 ); | |
237 | ||
238 | s5 += " value"; | |
239 | ||
240 | CPPUNIT_ASSERT( strcmp(s5.mb_str(), "ascii value") == 0 ); | |
241 | CPPUNIT_ASSERT_EQUAL( "ascii value", s5 ); | |
242 | CPPUNIT_ASSERT( s5 != "SomethingElse" ); | |
243 | } | |
244 | ||
245 | void UnicodeTestCase::ConversionFixed() | |
246 | { | |
247 | size_t len; | |
248 | ||
249 | #if wxUSE_UNICODE | |
250 | wxConvLibc.cWC2MB(L"", 0, &len); | |
251 | #else // !wxUSE_UNICODE | |
252 | wxConvLibc.cMB2WC("", 0, &len); | |
253 | #endif // wxUSE_UNICODE/!wxUSE_UNICODE | |
254 | ||
255 | CPPUNIT_ASSERT_EQUAL( 0, len ); | |
256 | ||
257 | #if wxUSE_UNICODE | |
258 | // check that when we convert a fixed number of characters we obtain the | |
259 | // expected return value | |
260 | CPPUNIT_ASSERT_EQUAL( 0, wxConvLibc.ToWChar(NULL, 0, "", 0) ); | |
261 | CPPUNIT_ASSERT_EQUAL( 1, wxConvLibc.ToWChar(NULL, 0, "x", 1) ); | |
262 | CPPUNIT_ASSERT_EQUAL( 2, wxConvLibc.ToWChar(NULL, 0, "x", 2) ); | |
263 | CPPUNIT_ASSERT_EQUAL( 2, wxConvLibc.ToWChar(NULL, 0, "xy", 2) ); | |
264 | #endif // wxUSE_UNICODE | |
265 | } | |
266 | ||
267 | void UnicodeTestCase::ConversionWithNULs() | |
268 | { | |
269 | #if wxUSE_UNICODE | |
270 | static const size_t lenNulString = 10; | |
271 | ||
272 | wxString szTheString(L"The\0String", wxConvLibc, lenNulString); | |
273 | wxCharBuffer theBuffer = szTheString.mb_str(); | |
274 | ||
275 | CPPUNIT_ASSERT( memcmp(theBuffer.data(), "The\0String", | |
276 | lenNulString + 1) == 0 ); | |
277 | ||
278 | wxString szTheString2("The\0String", wxConvLocal, lenNulString); | |
279 | CPPUNIT_ASSERT_EQUAL( lenNulString, szTheString2.length() ); | |
280 | CPPUNIT_ASSERT( wxTmemcmp(szTheString2.c_str(), L"The\0String", | |
281 | lenNulString + 1) == 0 ); | |
282 | #else // !wxUSE_UNICODE | |
283 | wxString szTheString("TheString"); | |
284 | szTheString.insert(3, 1, '\0'); | |
285 | wxWCharBuffer theBuffer = szTheString.wc_str(wxConvLibc); | |
286 | ||
287 | CPPUNIT_ASSERT( memcmp(theBuffer.data(), L"The\0String", 11 * sizeof(wchar_t)) == 0 ); | |
288 | ||
289 | wxString szLocalTheString("TheString"); | |
290 | szLocalTheString.insert(3, 1, '\0'); | |
291 | wxWCharBuffer theLocalBuffer = szLocalTheString.wc_str(wxConvLocal); | |
292 | ||
293 | CPPUNIT_ASSERT( memcmp(theLocalBuffer.data(), L"The\0String", 11 * sizeof(wchar_t)) == 0 ); | |
294 | #endif // wxUSE_UNICODE/!wxUSE_UNICODE | |
295 | } | |
296 | ||
297 | void UnicodeTestCase::ConversionUTF7() | |
298 | { | |
299 | static const StringConversionData utf7data[] = | |
300 | { | |
301 | // normal fragments | |
302 | StringConversionData("+AKM-", L"\xa3"), | |
303 | StringConversionData("+AOk-t+AOk-", L"\xe9t\xe9"), | |
304 | ||
305 | // this one is an alternative valid encoding of the same string | |
306 | StringConversionData("+AOk-t+AOk", L"\xe9t\xe9", | |
307 | StringConversionData::ONLY_MB2WC), | |
308 | ||
309 | // some special cases | |
310 | StringConversionData("+-", L"+"), | |
311 | StringConversionData("+--", L"+-"), | |
312 | ||
313 | // the following are invalid UTF-7 sequences | |
314 | StringConversionData("\xa3", NULL), | |
315 | StringConversionData("+", NULL), | |
316 | StringConversionData("+~", NULL), | |
317 | StringConversionData("a+", NULL), | |
318 | }; | |
319 | ||
320 | for ( size_t n = 0; n < WXSIZEOF(utf7data); n++ ) | |
321 | { | |
322 | const StringConversionData& d = utf7data[n]; | |
323 | ||
324 | // converting to/from UTF-7 using iconv() currently doesn't work | |
325 | // because of several problems: | |
326 | // - GetMBNulLen() doesn't return correct result (iconv converts L'\0' | |
327 | // to an incomplete and anyhow nonsensical "+AA" string) | |
328 | // - iconv refuses to convert "+-" (although it converts "+-\n" just | |
329 | // fine, go figure) | |
330 | // | |
331 | // I have no idea how to fix this so just disable the test for now | |
332 | #if 0 | |
333 | d.Test(n, wxCSConv("utf-7")); | |
334 | #endif | |
335 | d.Test(n, wxConvUTF7); | |
336 | } | |
337 | } | |
338 | ||
339 | void UnicodeTestCase::ConversionUTF8() | |
340 | { | |
341 | static const StringConversionData utf8data[] = | |
342 | { | |
343 | #ifdef wxHAVE_U_ESCAPE | |
344 | StringConversionData("\xc2\xa3", L"\u00a3"), | |
345 | #endif | |
346 | StringConversionData("\xc2", NULL), | |
347 | }; | |
348 | ||
349 | wxCSConv conv(wxT("utf-8")); | |
350 | for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ ) | |
351 | { | |
352 | const StringConversionData& d = utf8data[n]; | |
353 | d.Test(n, conv); | |
354 | d.Test(n, wxConvUTF8); | |
355 | } | |
356 | } | |
357 | ||
358 | void UnicodeTestCase::ConversionUTF16() | |
359 | { | |
360 | static const StringConversionData utf16data[] = | |
361 | { | |
362 | #ifdef wxHAVE_U_ESCAPE | |
363 | StringConversionData( | |
364 | "\x04\x1f\x04\x40\x04\x38\x04\x32\x04\x35\x04\x42\0\0", | |
365 | L"\u041f\u0440\u0438\u0432\u0435\u0442"), | |
366 | StringConversionData( | |
367 | "\x01\0\0b\x01\0\0a\x01\0\0r\0\0", | |
368 | L"\u0100b\u0100a\u0100r"), | |
369 | #endif | |
370 | StringConversionData("\0f\0o\0o\0\0", L"foo"), | |
371 | }; | |
372 | ||
373 | wxCSConv conv(wxFONTENCODING_UTF16BE); | |
374 | for ( size_t n = 0; n < WXSIZEOF(utf16data); n++ ) | |
375 | { | |
376 | const StringConversionData& d = utf16data[n]; | |
377 | d.Test(n, conv); | |
378 | } | |
379 | ||
380 | // special case: this string has consecutive NULs inside it which don't | |
381 | // terminate the string, this exposed a bug in our conversion code which | |
382 | // got confused in this case | |
383 | size_t len; | |
384 | conv.cMB2WC("\x01\0\0B\0C" /* A macron BC */, 6, &len); | |
385 | CPPUNIT_ASSERT_EQUAL( 3, len ); | |
386 | } | |
387 | ||
388 | void UnicodeTestCase::ConversionUTF32() | |
389 | { | |
390 | static const StringConversionData utf32data[] = | |
391 | { | |
392 | #ifdef wxHAVE_U_ESCAPE | |
393 | StringConversionData( | |
394 | "\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", | |
395 | L"\u041f\u0440\u0438\u0432\u0435\u0442"), | |
396 | #endif | |
397 | StringConversionData("\0\0\0f\0\0\0o\0\0\0o\0\0\0\0", L"foo"), | |
398 | }; | |
399 | ||
400 | wxCSConv conv(wxFONTENCODING_UTF32BE); | |
401 | for ( size_t n = 0; n < WXSIZEOF(utf32data); n++ ) | |
402 | { | |
403 | const StringConversionData& d = utf32data[n]; | |
404 | d.Test(n, conv); | |
405 | } | |
406 | ||
407 | size_t len; | |
408 | conv.cMB2WC("\0\0\x01\0\0\0\0B\0\0\0C" /* A macron BC */, 12, &len); | |
409 | CPPUNIT_ASSERT_EQUAL( 3, len ); | |
410 | } | |
411 | ||
412 | void UnicodeTestCase::IsConvOk() | |
413 | { | |
414 | CPPUNIT_ASSERT( wxCSConv(wxFONTENCODING_SYSTEM).IsOk() ); | |
415 | CPPUNIT_ASSERT( wxCSConv("US-ASCII").IsOk() ); | |
416 | CPPUNIT_ASSERT( wxCSConv("UTF-8").IsOk() ); | |
417 | CPPUNIT_ASSERT( !wxCSConv("NoSuchConversion").IsOk() ); | |
418 | ||
419 | #ifdef __WINDOWS__ | |
420 | CPPUNIT_ASSERT( wxCSConv("WINDOWS-437").IsOk() ); | |
421 | #endif | |
422 | } | |
423 | ||
424 | #if wxUSE_UNICODE | |
425 | void UnicodeTestCase::Iteration() | |
426 | { | |
427 | // "czech" in Czech ("cestina"): | |
428 | static const char *textUTF8 = "\304\215e\305\241tina"; | |
429 | static const wchar_t textUTF16[] = {0x10D, 0x65, 0x161, 0x74, 0x69, 0x6E, 0x61, 0}; | |
430 | ||
431 | wxString text(wxString::FromUTF8(textUTF8)); | |
432 | CPPUNIT_ASSERT( wxStrcmp(text.wc_str(), textUTF16) == 0 ); | |
433 | ||
434 | // verify the string was decoded correctly: | |
435 | { | |
436 | size_t idx = 0; | |
437 | for ( wxString::const_iterator i = text.begin(); i != text.end(); ++i, ++idx ) | |
438 | { | |
439 | CPPUNIT_ASSERT( *i == textUTF16[idx] ); | |
440 | } | |
441 | } | |
442 | ||
443 | // overwrite the string with something that is shorter in UTF-8: | |
444 | { | |
445 | for ( wxString::iterator i = text.begin(); i != text.end(); ++i ) | |
446 | *i = 'x'; | |
447 | } | |
448 | ||
449 | // restore the original text now: | |
450 | { | |
451 | wxString::iterator end1 = text.end(); | |
452 | wxString::const_iterator end2 = text.end(); | |
453 | ||
454 | size_t idx = 0; | |
455 | for ( wxString::iterator i = text.begin(); i != text.end(); ++i, ++idx ) | |
456 | { | |
457 | *i = textUTF16[idx]; | |
458 | ||
459 | CPPUNIT_ASSERT( end1 == text.end() ); | |
460 | CPPUNIT_ASSERT( end2 == text.end() ); | |
461 | } | |
462 | ||
463 | CPPUNIT_ASSERT( end1 == text.end() ); | |
464 | CPPUNIT_ASSERT( end2 == text.end() ); | |
465 | } | |
466 | ||
467 | // and verify it again: | |
468 | { | |
469 | size_t idx = 0; | |
470 | for ( wxString::const_iterator i = text.begin(); i != text.end(); ++i, ++idx ) | |
471 | { | |
472 | CPPUNIT_ASSERT( *i == textUTF16[idx] ); | |
473 | } | |
474 | } | |
475 | } | |
476 | #endif // wxUSE_UNICODE | |
477 |