1 #include <string>
2
3 #if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
4 # include <fstream>
5 # include <locale>
6 # include <stdexcept>
7 # include <cstdio> // for WEOF
8
9 # include "cppunit/cppunit_proxy.h"
10
11 # if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
12 using namespace std;
13 # endif
14
15 //
16 // TestCase class
17 //
18 class CodecvtTest : public CPPUNIT_NS::TestCase
19 {
20 CPPUNIT_TEST_SUITE(CodecvtTest);
21 #if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)
22 CPPUNIT_IGNORE;
23 #endif
24 CPPUNIT_TEST(variable_encoding);
25 CPPUNIT_STOP_IGNORE;
26 #if defined (STLPORT) && (defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
27 CPPUNIT_IGNORE;
28 #endif
29 CPPUNIT_TEST(in_out_test);
30 CPPUNIT_TEST(length_test);
31 CPPUNIT_TEST(imbue_while_reading);
32 CPPUNIT_TEST(special_encodings);
33 CPPUNIT_TEST_SUITE_END();
34
35 protected:
36 void variable_encoding();
37 void in_out_test();
38 void length_test();
39 void imbue_while_reading();
40 void special_encodings();
41 };
42
43 CPPUNIT_TEST_SUITE_REGISTRATION(CodecvtTest);
44
45 #if defined (STLPORT)
46 # define __NO_THROW _STLP_NOTHROW
47 #else
48 # define __NO_THROW throw()
49 #endif
50
51
52 /* Codecvt facet eating some characters from the external buffer.
53 * Transform '01' in 'a'
54 */
55 struct eater_codecvt : public codecvt<char, char, mbstate_t> {
56 typedef codecvt<char,char,mbstate_t> base;
57
eater_codecvteater_codecvt58 explicit eater_codecvt(size_t refs = 0) : base(refs) {}
59
60 // primitive conversion
61 virtual base::result
do_ineater_codecvt62 do_in(mbstate_t& mb,
63 const char* ebegin, const char* eend, const char*& ecur,
64 char* ibegin, char* iend, char*& icur) const __NO_THROW {
65 char *state = (char*)&mb;
66 ecur = ebegin;
67 icur = ibegin;
68
69 while (ecur != eend) {
70 if (icur == iend)
71 return partial;
72 if (*ecur == '0' || *state == 1) {
73 if (*state != 1) {
74 ++ecur;
75 }
76 if (ecur == eend) {
77 *state = 1;
78 return ok;
79 }
80
81 if (*ecur == '1') {
82 *icur = 'a';
83 }
84 else {
85 *(icur++) = '0';
86 if (icur == iend) {
87 if (*state != 1) {
88 --ecur;
89 }
90 return partial;
91 }
92 *icur = *ecur;
93 }
94 }
95 else {
96 *icur = *ecur;
97 }
98
99 *state = 0;
100 ++icur;
101 ++ecur;
102 }
103
104 return ok;
105 }
106
107 // claim it's not a null-conversion
do_always_noconveater_codecvt108 virtual bool do_always_noconv() const __NO_THROW
109 { return false; }
110
111 // claim it doesn't have a fixed-length encoding
do_encodingeater_codecvt112 virtual int do_encoding() const __NO_THROW
113 { return 0; }
114
115 // implemented for consistency with do_in overload
do_lengtheater_codecvt116 virtual int do_length(mbstate_t &state,
117 const char *efrom, const char *eend, size_t m) const {
118 char *ibegin = new char[m];
119 const char *ecur = efrom;
120 char *icur = ibegin;
121 mbstate_t tmp = state;
122 do_in(tmp, efrom, eend, ecur, ibegin, ibegin + m, icur);
123 delete[] ibegin;
124 return ecur - efrom;
125 }
126
do_max_lengtheater_codecvt127 virtual int do_max_length() const __NO_THROW
128 { return 2; }
129
130 #ifdef __DMC__
131 static locale::id id;
132 #endif
133 };
134
135 #ifdef __DMC__
136 locale::id eater_codecvt::id;
137
_GetFacetId(const eater_codecvt *)138 locale::id& _GetFacetId(const eater_codecvt*)
139 { return eater_codecvt::id; }
140 #endif
141
142 /* Codecvt facet generating more characters than the ones read from the
143 * external buffer, transform '01' in 'abc'
144 * This kind of facet do not allow systematical positionning in the external
145 * buffer (tellg -> -1), when you just read a 'a' you are at an undefined
146 * external buffer position.
147 */
148 struct generator_codecvt : public codecvt<char, char, mbstate_t> {
149 typedef codecvt<char,char,mbstate_t> base;
150
generator_codecvtgenerator_codecvt151 explicit generator_codecvt(size_t refs = 0) : base(refs) {}
152
153 // primitive conversion
154 virtual base::result
do_ingenerator_codecvt155 do_in(mbstate_t& mb,
156 const char* ebegin, const char* eend, const char*& ecur,
157 char* ibegin, char* iend, char*& icur) const __NO_THROW {
158 //Access the mbstate information in a portable way:
159 char *state = (char*)&mb;
160 ecur = ebegin;
161 icur = ibegin;
162
163 if (icur == iend) return ok;
164
165 if (*state == 2) {
166 *(icur++) = 'b';
167 if (icur == iend) {
168 *state = 3;
169 return ok;
170 }
171 *(icur++) = 'c';
172 *state = 0;
173 }
174 else if (*state == 3) {
175 *(icur++) = 'c';
176 *state = 0;
177 }
178
179 while (ecur != eend) {
180 if (icur == iend)
181 return ok;
182 if (*ecur == '0' || *state == 1) {
183 if (*state != 1) {
184 ++ecur;
185 }
186 if (ecur == eend) {
187 *state = 1;
188 return partial;
189 }
190
191 if (*ecur == '1') {
192 *(icur++) = 'a';
193 if (icur == iend) {
194 *state = 2;
195 return ok;
196 }
197 *(icur++) = 'b';
198 if (icur == iend) {
199 *state = 3;
200 return ok;
201 }
202 *icur = 'c';
203 }
204 else {
205 *(icur++) = '0';
206 if (icur == iend) {
207 if (*state != 1) {
208 --ecur;
209 }
210 return ok;
211 }
212 *icur = *ecur;
213 }
214 }
215 else {
216 *icur = *ecur;
217 }
218
219 *state = 0;
220 ++icur;
221 ++ecur;
222 }
223
224 return ok;
225 }
226
227 // claim it's not a null-conversion
do_always_noconvgenerator_codecvt228 virtual bool do_always_noconv() const __NO_THROW
229 { return false; }
230
231 // claim it doesn't have a fixed-length encoding
do_encodinggenerator_codecvt232 virtual int do_encoding() const __NO_THROW
233 { return 0; }
234
235 // implemented for consistency with do_in overload
do_lengthgenerator_codecvt236 virtual int do_length(mbstate_t &mb,
237 const char *efrom, const char *eend, size_t m) const {
238 const char *state = (const char*)&mb;
239 int offset = 0;
240 if (*state == 2)
241 offset = 2;
242 else if (*state == 3)
243 offset = 1;
244
245 char *ibegin = new char[m + offset];
246 const char *ecur = efrom;
247 char *icur = ibegin;
248 mbstate_t tmpState = mb;
249 do_in(tmpState, efrom, eend, ecur, ibegin, ibegin + m + offset, icur);
250 /*
251 char *state = (char*)&tmpState;
252 if (*state != 0) {
253 if (*state == 1)
254 --ecur;
255 else if (*state == 2 || *state == 3) {
256 //Undefined position, we return -1:
257 ecur = efrom - 1;
258 }
259 }
260 else {
261 if (*((char*)&mb) != 0) {
262 //We take into account the character that hasn't been counted yet in
263 //the previous decoding step:
264 ecur++;
265 }
266 }
267 */
268 delete[] ibegin;
269 return (int)min((size_t)(ecur - efrom), m);
270 }
271
do_max_lengthgenerator_codecvt272 virtual int do_max_length() const __NO_THROW
273 { return 0; }
274 #ifdef __DMC__
275 static locale::id id;
276 #endif
277 };
278
279 #ifdef __DMC__
280 locale::id generator_codecvt::id;
281
_GetFacetId(const generator_codecvt *)282 locale::id& _GetFacetId(const generator_codecvt*)
283 { return generator_codecvt::id; }
284 #endif
285
286 //
287 // tests implementation
288 //
289 #include <iostream>
variable_encoding()290 void CodecvtTest::variable_encoding()
291 {
292 #if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
293 //We first generate the file used for test:
294 const char* fileName = "test_file.txt";
295 {
296 ofstream ostr(fileName);
297 //Maybe we simply do not have write access to repository
298 CPPUNIT_ASSERT( ostr.good() );
299 for (int i = 0; i < 2048; ++i) {
300 ostr << "0123456789";
301 }
302 CPPUNIT_ASSERT( ostr.good() );
303 }
304
305 {
306 ifstream istr(fileName);
307 CPPUNIT_ASSERT( istr.good() );
308 CPPUNIT_ASSERT( !istr.eof() );
309
310 eater_codecvt codec(1);
311 locale loc(locale::classic(), &codec);
312
313 istr.imbue(loc);
314 CPPUNIT_ASSERT( istr.good() );
315 CPPUNIT_ASSERT( (int)istr.tellg() == 0 );
316
317 int theoricalPos = 0;
318 do {
319 int c = istr.get();
320 if (char_traits<char>::eq_int_type(c, char_traits<char>::eof())) {
321 break;
322 }
323 ++theoricalPos;
324 if (c == 'a') {
325 ++theoricalPos;
326 }
327
328 CPPUNIT_ASSERT( (int)istr.tellg() == theoricalPos );
329 }
330 while (!istr.eof());
331 cerr << "out!\n";
332 CPPUNIT_ASSERT( istr.eof() );
333 cerr << "fin!\n";
334 }
335
336 # if 0
337 /* This test is broken, not sure if it is really possible to get a position in
338 * a locale having a codecvt such as generator_codecvt. Maybe generator_codecvt
339 * is not a valid theorical example of codecvt implementation. */
340 {
341 ifstream istr(fileName);
342 CPPUNIT_ASSERT( istr.good() );
343 CPPUNIT_ASSERT( !istr.eof() );
344
345 generator_codecvt codec(1);
346 locale loc(locale::classic(), &codec);
347
348 istr.imbue(loc);
349 CPPUNIT_ASSERT( istr.good() );
350 CPPUNIT_ASSERT( (int)istr.tellg() == 0 );
351
352 int theoricalPos = 0;
353 int theoricalTellg;
354 do {
355 char c = istr.get();
356 if (c == char_traits<char>::eof()) {
357 break;
358 }
359 switch (c) {
360 case 'a':
361 case 'b':
362 theoricalTellg = -1;
363 break;
364 case 'c':
365 ++theoricalPos;
366 default:
367 ++theoricalPos;
368 theoricalTellg = theoricalPos;
369 break;
370 }
371
372 if ((int)istr.tellg() != theoricalTellg) {
373 CPPUNIT_ASSERT( (int)istr.tellg() == theoricalTellg );
374 }
375 }
376 while (!istr.eof());
377
378 CPPUNIT_ASSERT( istr.eof() );
379 }
380 # endif
381 #endif
382 }
383
in_out_test()384 void CodecvtTest::in_out_test()
385 {
386 #if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
387 try {
388 locale loc("");
389
390 typedef codecvt<wchar_t, char, mbstate_t> cdecvt_type;
391 if (has_facet<cdecvt_type>(loc)) {
392 cdecvt_type const& cdect = use_facet<cdecvt_type>(loc);
393 {
394 cdecvt_type::state_type state;
395 memset(&state, 0, sizeof(cdecvt_type::state_type));
396 string from("abcdef");
397 const char* next_from;
398 wchar_t to[1];
399 wchar_t *next_to;
400 cdecvt_type::result res = cdect.in(state, from.data(), from.data() + from.size(), next_from,
401 to, to + sizeof(to) / sizeof(wchar_t), next_to);
402 CPPUNIT_ASSERT( res == cdecvt_type::ok );
403 CPPUNIT_ASSERT( next_from == from.data() + 1 );
404 CPPUNIT_ASSERT( next_to == &to[0] + 1 );
405 CPPUNIT_ASSERT( to[0] == L'a');
406 }
407 {
408 cdecvt_type::state_type state;
409 memset(&state, 0, sizeof(cdecvt_type::state_type));
410 wstring from(L"abcdef");
411 const wchar_t* next_from;
412 char to[1];
413 char *next_to;
414 cdecvt_type::result res = cdect.out(state, from.data(), from.data() + from.size(), next_from,
415 to, to + sizeof(to) / sizeof(char), next_to);
416 CPPUNIT_ASSERT( res == cdecvt_type::ok );
417 CPPUNIT_ASSERT( next_from == from.data() + 1 );
418 CPPUNIT_ASSERT( next_to == &to[0] + 1 );
419 CPPUNIT_ASSERT( to[0] == 'a');
420 }
421 }
422 }
423 catch (runtime_error const&) {
424 }
425 catch (...) {
426 CPPUNIT_FAIL;
427 }
428 #endif
429 }
430
length_test()431 void CodecvtTest::length_test()
432 {
433 #if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
434 try {
435 locale loc("");
436
437 typedef codecvt<wchar_t, char, mbstate_t> cdecvt_type;
438 if (has_facet<cdecvt_type>(loc)) {
439 cdecvt_type const& cdect = use_facet<cdecvt_type>(loc);
440 {
441 cdecvt_type::state_type state;
442 memset(&state, 0, sizeof(cdecvt_type::state_type));
443 string from("abcdef");
444 int res = cdect.length(state, from.data(), from.data() + from.size(), from.size());
445 CPPUNIT_ASSERT( (size_t)res == from.size() );
446 }
447 }
448 }
449 catch (runtime_error const&) {
450 }
451 catch (...) {
452 CPPUNIT_FAIL;
453 }
454 #endif
455 }
456
457 #if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
458 typedef std::codecvt<wchar_t, char, mbstate_t> my_codecvt_base;
459
460 class my_codecvt : public my_codecvt_base {
461 public:
my_codecvt(size_t r=0)462 explicit my_codecvt(size_t r = 0)
463 : my_codecvt_base(r) {}
464
465 protected:
do_in(state_type &,const extern_type * first1,const extern_type * last1,const extern_type * & next1,intern_type * first2,intern_type * last2,intern_type * & next2) const466 virtual result do_in(state_type& /*state*/, const extern_type* first1,
467 const extern_type* last1, const extern_type*& next1,
468 intern_type* first2, intern_type* last2,
469 intern_type*& next2) const {
470 for ( next1 = first1, next2 = first2; next1 < last1; next1 += 2 ) {
471 if ( (last1 - next1) < 2 || (last2 - next2) < 1 )
472 return partial;
473 *next2++ = (intern_type)((*(next1 + 1) << 8) | (*next1 & 255));
474 }
475 return ok;
476 }
do_always_noconv() const477 virtual bool do_always_noconv() const __NO_THROW
478 { return false; }
do_max_length() const479 virtual int do_max_length() const __NO_THROW
480 { return 2; }
do_encoding() const481 virtual int do_encoding() const __NO_THROW
482 { return 2; }
483 };
484 #endif
485
imbue_while_reading()486 void CodecvtTest::imbue_while_reading()
487 {
488 #if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
489 {
490 wofstream ofs( "test.txt" );
491 const wchar_t buf[] = L" ";
492 for ( int i = 0; i < 4098; ++i ) {
493 ofs << buf[0];
494 }
495 }
496
497 wifstream ifs("test.txt"); // a file containing 4098 wchars
498
499 ifs.imbue( locale(locale(), new my_codecvt) );
500 ifs.get();
501 ifs.seekg(0);
502 ifs.imbue( locale() );
503 ifs.ignore(4096);
504 int ch = ifs.get();
505 CPPUNIT_CHECK( ch != (int)WEOF );
506 #endif
507 }
508
special_encodings()509 void CodecvtTest::special_encodings()
510 {
511 #if !defined (STLPORT) || (!defined (_STLP_NO_WCHAR_T) && defined (_STLP_USE_EXCEPTIONS))
512 {
513 locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>("C"));
514 codecvt<wchar_t, char, mbstate_t> const& cvt = use_facet<codecvt<wchar_t, char, mbstate_t> >(loc);
515 mbstate_t state;
516 memset(&state, 0, sizeof(mbstate_t));
517 char c = '0';
518 const char *from_next;
519 wchar_t wc;
520 wchar_t *to_next;
521 CPPUNIT_ASSERT( cvt.in(state, &c, &c + 1, from_next, &wc, &wc, to_next) == codecvt_base::ok );
522 CPPUNIT_ASSERT( to_next == &wc );
523 CPPUNIT_ASSERT( cvt.in(state, &c, &c + 1, from_next, &wc, &wc + 1, to_next) == codecvt_base::ok );
524 CPPUNIT_ASSERT( wc == L'0' );
525 CPPUNIT_ASSERT( to_next == &wc + 1 );
526 }
527 try
528 {
529 wstring cp936_wstr;
530 const string cp936_str = "\xd6\xd0\xb9\xfa\xc9\xe7\xbb\xe1\xbf\xc6\xd1\xa7\xd4\xba\xb7\xa2\xb2\xbc\x32\x30\x30\x38\xc4\xea\xa1\xb6\xbe\xad\xbc\xc3\xc0\xb6\xc6\xa4\xca\xe9\xa1\xb7\xd6\xb8\xb3\xf6\xa3\xac\x32\x30\x30\x37\xc4\xea\xd6\xd0\xb9\xfa\xbe\xad\xbc\xc3\xd4\xf6\xb3\xa4\xd3\xc9\xc6\xab\xbf\xec\xd7\xaa\xcf\xf2\xb9\xfd\xc8\xc8\xb5\xc4\xc7\xf7\xca\xc6\xc3\xf7\xcf\xd4\xd4\xa4\xbc\xc6\xc8\xab\xc4\xea\x47\x44\x50\xd4\xf6\xcb\xd9\xbd\xab\xb4\xef\x31\x31\x2e\x36\x25\xa1\xa3";
531 locale loc(locale::classic(), ".936", locale::ctype);
532 codecvt<wchar_t, char, mbstate_t> const& cvt = use_facet<codecvt<wchar_t, char, mbstate_t> >(loc);
533 mbstate_t state;
534 memset(&state, 0, sizeof(mbstate_t));
535
536 codecvt_base::result res;
537
538 {
539 wchar_t wbuf[4096];
540 // Check we will have enough room for the generated wide string generated from the whole char buffer:
541 int len = cvt.length(state, cp936_str.data(), cp936_str.data() + cp936_str.size(), sizeof(wbuf) / sizeof(wchar_t));
542 CPPUNIT_ASSERT( cp936_str.size() == (size_t)len );
543
544 const char *from_next;
545 wchar_t *to_next;
546 res = cvt.in(state, cp936_str.data(), cp936_str.data() + cp936_str.size(), from_next,
547 wbuf, wbuf + sizeof(wbuf) / sizeof(wchar_t), to_next);
548 CPPUNIT_ASSERT( res == codecvt_base::ok );
549 CPPUNIT_ASSERT( from_next == cp936_str.data() + cp936_str.size() );
550 cp936_wstr.assign(wbuf, to_next);
551 }
552
553 {
554 const wchar_t *from_next;
555 char buf[4096];
556 char *to_next;
557 res = cvt.out(state, cp936_wstr.data(), cp936_wstr.data() + cp936_wstr.size(), from_next,
558 buf, buf + sizeof(buf), to_next);
559 CPPUNIT_ASSERT( res == codecvt_base::ok );
560 CPPUNIT_CHECK( string(buf, to_next) == cp936_str );
561 }
562 }
563 catch (const runtime_error&)
564 {
565 CPPUNIT_MESSAGE("Not enough platform localization support to check 936 code page encoding.");
566 }
567 try
568 {
569 const string utf8_str = "\xe4\xb8\xad\xe5\x9b\xbd\xe7\xa4\xbe\xe4\xbc\x9a\xe7\xa7\x91\xe5\xad\xa6\xe9\x99\xa2\xe5\x8f\x91\xe5\xb8\x83\x32\x30\x30\x38\xe5\xb9\xb4\xe3\x80\x8a\xe7\xbb\x8f\xe6\xb5\x8e\xe8\x93\x9d\xe7\x9a\xae\xe4\xb9\xa6\xe3\x80\x8b\xe6\x8c\x87\xe5\x87\xba\xef\xbc\x8c\x32\x30\x30\x37\xe5\xb9\xb4\xe4\xb8\xad\xe5\x9b\xbd\xe7\xbb\x8f\xe6\xb5\x8e\xe5\xa2\x9e\xe9\x95\xbf\xe7\x94\xb1\xe5\x81\x8f\xe5\xbf\xab\xe8\xbd\xac\xe5\x90\x91\xe8\xbf\x87\xe7\x83\xad\xe7\x9a\x84\xe8\xb6\x8b\xe5\x8a\xbf\xe6\x98\x8e\xe6\x98\xbe\xe9\xa2\x84\xe8\xae\xa1\xe5\x85\xa8\xe5\xb9\xb4\x47\x44\x50\xe5\xa2\x9e\xe9\x80\x9f\xe5\xb0\x86\xe8\xbe\xbe\x31\x31\x2e\x36\x25\xe3\x80\x82";
570 wstring utf8_wstr;
571 locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(".utf8"));
572 codecvt<wchar_t, char, mbstate_t> const& cvt = use_facet<codecvt<wchar_t, char, mbstate_t> >(loc);
573 mbstate_t state;
574 memset(&state, 0, sizeof(mbstate_t));
575
576 codecvt_base::result res;
577
578 {
579 wchar_t wbuf[4096];
580 // Check we will have enough room for the wide string generated from the whole char buffer:
581 int len = cvt.length(state, utf8_str.data(), utf8_str.data() + utf8_str.size(), sizeof(wbuf) / sizeof(wchar_t));
582 CPPUNIT_ASSERT( utf8_str.size() == (size_t)len );
583
584 const char *from_next;
585 wchar_t *to_next;
586 res = cvt.in(state, utf8_str.data(), utf8_str.data() + utf8_str.size(), from_next,
587 wbuf, wbuf + sizeof(wbuf) / sizeof(wchar_t), to_next);
588 CPPUNIT_ASSERT( res == codecvt_base::ok );
589 CPPUNIT_ASSERT( from_next == utf8_str.data() + utf8_str.size() );
590 utf8_wstr.assign(wbuf, to_next);
591
592 // Try to read one char after the other:
593 wchar_t wc;
594 const char* from = utf8_str.data();
595 const char* from_end = from + utf8_str.size();
596 from_next = utf8_str.data();
597 size_t length = 1;
598 size_t windex = 0;
599 while (from + length <= from_end) {
600 res = cvt.in(state, from, from + length, from_next,
601 &wc, &wc + 1, to_next);
602 switch (res) {
603 case codecvt_base::ok:
604 // reset length:
605 from = from_next;
606 length = 1;
607 CPPUNIT_ASSERT( wc == utf8_wstr[windex++] );
608 wc = 0;
609 break;
610 case codecvt_base::partial:
611 if (from_next == from)
612 // from_next hasn't move so we have to pass more chars
613 ++length;
614 else
615 // char between from and from_next has been eaten, we simply restart
616 // conversion from from_next:
617 from = from_next;
618 continue;
619 case codecvt_base::error:
620 case codecvt_base::noconv:
621 CPPUNIT_FAIL;
622 //break;
623 }
624 }
625 CPPUNIT_ASSERT( windex == utf8_wstr.size() );
626 }
627
628 {
629 const wchar_t *from_next;
630 char buf[4096];
631 char *to_next;
632 res = cvt.out(state, utf8_wstr.data(), utf8_wstr.data() + utf8_wstr.size(), from_next,
633 buf, buf + sizeof(buf), to_next);
634 CPPUNIT_ASSERT( res == codecvt_base::ok );
635 CPPUNIT_CHECK( string(buf, to_next) == utf8_str );
636 }
637
638 {
639 // Check that an obviously wrong UTF8 encoded string is correctly detected:
640 const string bad_utf8_str("\xdf\xdf\xdf\xdf\xdf");
641 wchar_t wc;
642 const char *from_next;
643 wchar_t *to_next;
644 res = cvt.in(state, bad_utf8_str.data(), bad_utf8_str.data() + bad_utf8_str.size(), from_next,
645 &wc, &wc + 1, to_next);
646 CPPUNIT_ASSERT( res == codecvt_base::error );
647 }
648 }
649 catch (const runtime_error&)
650 {
651 CPPUNIT_MESSAGE("Not enough platform localization support to check UTF8 encoding.");
652 }
653 #endif
654 }
655
656 #endif
657