X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8650108199bf799f21e29811cddaefd579c98c88..0d1903dbda864780eec30efdc4e91776bdbfd21b:/tests/mbconv/mbconvtest.cpp?ds=sidebyside diff --git a/tests/mbconv/mbconvtest.cpp b/tests/mbconv/mbconvtest.cpp index dde306ab6c..49369327b4 100644 --- a/tests/mbconv/mbconvtest.cpp +++ b/tests/mbconv/mbconvtest.cpp @@ -3,7 +3,6 @@ // Purpose: wxMBConv unit test // Author: Vadim Zeitlin, Mike Wetherell, Vince Harron // Created: 14.02.04 -// RCS-ID: $Id$ // Copyright: (c) 2003 TT-Solutions, (c) 2005 Mike Wetherell, Vince Harron /////////////////////////////////////////////////////////////////////////////// @@ -78,7 +77,10 @@ private: CPPUNIT_TEST( CP1252Tests ); // depends on UTF8 Decoder functioning correctly CPPUNIT_TEST( LibcTests ); CPPUNIT_TEST( IconvTests ); + CPPUNIT_TEST( Latin1Tests ); CPPUNIT_TEST( FontmapTests ); + CPPUNIT_TEST( BufSize ); + CPPUNIT_TEST( FromWCharTests ); #ifdef HAVE_WCHAR_H CPPUNIT_TEST( UTF8_41 ); CPPUNIT_TEST( UTF8_7f ); @@ -112,7 +114,10 @@ private: void CP1252Tests(); void LibcTests(); void FontmapTests(); + void BufSize(); + void FromWCharTests(); void IconvTests(); + void Latin1Tests(); // verifies that the specified multibyte sequence decodes to the specified wchar_t sequence void TestDecoder( @@ -211,7 +216,7 @@ private: // register in the unnamed registry so that these tests are run by default CPPUNIT_TEST_SUITE_REGISTRATION( MBConvTestCase ); -// also include in it's own registry so that these tests can be run alone +// also include in its own registry so that these tests can be run alone CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( MBConvTestCase, "MBConvTestCase" ); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( MBConvTestCase, "MBConv" ); @@ -250,30 +255,30 @@ wxString CByteArrayFormat( const void* data, size_t len, const wxChar* name ) const unsigned char* bytes = (unsigned char*)data; wxString result; - result.Printf( _T("const static unsigned char %s[%i] = \n{"), name, (int)len ); + result.Printf( wxT("static const unsigned char %s[%i] = \n{"), name, (int)len ); for ( size_t i = 0; i < len; i++ ) { if ( i != 0 ) { - result.append( _T(",") ); + result.append( wxT(",") ); } if ((i%16)==0) { - result.append( _T("\n ") ); + result.append( wxT("\n ") ); } - wxString byte = wxString::Format( _T("0x%02x"), bytes[i] ); + wxString byte = wxString::Format( wxT("0x%02x"), bytes[i] ); result.append(byte); } - result.append( _T("\n};\n") ); + result.append( wxT("\n};\n") ); return result; } -// The following bytes represent the same string, containing Japanese and English +// The following bytes represent the same string, containing Japanese and English // characters, encoded in several different formats. // encoded by iconv -const static unsigned char welcome_utf7_iconv[84] = +static const unsigned char welcome_utf7_iconv[84] = { 0x57,0x65,0x6c,0x63,0x6f,0x6d,0x65,0x20,0x74,0x6f,0x20,0x6f,0x75,0x72,0x20,0x63, 0x79,0x62,0x65,0x72,0x20,0x73,0x70,0x61,0x63,0x65,0x20,0x66,0x6f,0x72,0x63,0x65, @@ -283,7 +288,7 @@ const static unsigned char welcome_utf7_iconv[84] = 0x57,0x54,0x41,0x43 }; // encoded by wxWindows (iconv can decode this successfully) -const static unsigned char welcome_utf7_wx[109] = +static const unsigned char welcome_utf7_wx[109] = { 0x57,0x65,0x6c,0x63,0x6f,0x6d,0x65,0x2b,0x41,0x43,0x41,0x2d,0x74,0x6f,0x2b,0x41, 0x43,0x41,0x2d,0x6f,0x75,0x72,0x2b,0x41,0x43,0x41,0x2d,0x63,0x79,0x62,0x65,0x72, @@ -294,7 +299,7 @@ const static unsigned char welcome_utf7_wx[109] = 0x51,0x77,0x52,0x44,0x42,0x6e,0x4d,0x46,0x6b,0x77,0x41,0x67,0x2d }; // encoded by iconv -const static unsigned char welcome_utf8[89] = +static const unsigned char welcome_utf8[89] = { 0x57,0x65,0x6c,0x63,0x6f,0x6d,0x65,0x20,0x74,0x6f,0x20,0x6f,0x75,0x72,0x20,0x63, 0x79,0x62,0x65,0x72,0x20,0x73,0x70,0x61,0x63,0x65,0x20,0x66,0x6f,0x72,0x63,0x65, @@ -304,7 +309,7 @@ const static unsigned char welcome_utf8[89] = 0xe3,0x81,0xa7,0xe3,0x81,0x99,0xe3,0x80,0x82 }; // encoded by iconv -const static unsigned char welcome_utf16le[106] = +static const unsigned char welcome_utf16le[106] = { 0x57,0x00,0x65,0x00,0x6c,0x00,0x63,0x00,0x6f,0x00,0x6d,0x00,0x65,0x00,0x20,0x00, 0x74,0x00,0x6f,0x00,0x20,0x00,0x6f,0x00,0x75,0x00,0x72,0x00,0x20,0x00,0x63,0x00, @@ -315,7 +320,7 @@ const static unsigned char welcome_utf16le[106] = 0x44,0x30,0x44,0x30,0x67,0x30,0x59,0x30,0x02,0x30 }; // encoded by iconv -const static unsigned char welcome_utf16be[106] = +static const unsigned char welcome_utf16be[106] = { 0x00,0x57,0x00,0x65,0x00,0x6c,0x00,0x63,0x00,0x6f,0x00,0x6d,0x00,0x65,0x00,0x20, 0x00,0x74,0x00,0x6f,0x00,0x20,0x00,0x6f,0x00,0x75,0x00,0x72,0x00,0x20,0x00,0x63, @@ -326,7 +331,7 @@ const static unsigned char welcome_utf16be[106] = 0x30,0x44,0x30,0x44,0x30,0x67,0x30,0x59,0x30,0x02 }; // encoded by iconv -const static unsigned char welcome_utf32le[212] = +static const unsigned char welcome_utf32le[212] = { 0x57,0x00,0x00,0x00,0x65,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x63,0x00,0x00,0x00, 0x6f,0x00,0x00,0x00,0x6d,0x00,0x00,0x00,0x65,0x00,0x00,0x00,0x20,0x00,0x00,0x00, @@ -344,7 +349,7 @@ const static unsigned char welcome_utf32le[212] = 0x02,0x30,0x00,0x00 }; // encoded by iconv -const static unsigned char welcome_utf32be[212] = +static const unsigned char welcome_utf32be[212] = { 0x00,0x00,0x00,0x57,0x00,0x00,0x00,0x65,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x63, 0x00,0x00,0x00,0x6f,0x00,0x00,0x00,0x6d,0x00,0x00,0x00,0x65,0x00,0x00,0x00,0x20, @@ -362,7 +367,7 @@ const static unsigned char welcome_utf32be[212] = 0x00,0x00,0x30,0x02 }; // encoded by iconv -const static unsigned char welcome_cp932[71] = +static const unsigned char welcome_cp932[71] = { 0x57,0x65,0x6c,0x63,0x6f,0x6d,0x65,0x20,0x74,0x6f,0x20,0x6f,0x75,0x72,0x20,0x63, 0x79,0x62,0x65,0x72,0x20,0x73,0x70,0x61,0x63,0x65,0x20,0x66,0x6f,0x72,0x63,0x65, @@ -387,45 +392,51 @@ const static unsigned char welcome_cp932[71] = void MBConvTestCase::UTF7Tests() { +#if 0 + wxCSConv convUTF7(wxFONTENCODING_UTF7); +#else + wxMBConvUTF7 convUTF7; +#endif + TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf7_iconv, - sizeof(welcome_utf7_iconv), - wxConvUTF7, + (const char*)welcome_utf7_iconv, + sizeof(welcome_utf7_iconv), + convUTF7, 1 ); TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf7_wx, - sizeof(welcome_utf7_wx), - wxConvUTF7, + (const char*)welcome_utf7_wx, + sizeof(welcome_utf7_wx), + convUTF7, 1 ); -#if 0 - // wxWidget's UTF-7 encoder generates different byte sequences than iconv's. +#if 0 + // wxWidget's UTF-7 encoder generates different byte sequences than iconv's. // but both seem to be equally legal. // This test won't work and that's okay. TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf7_iconv, - sizeof(welcome_utf7_iconv), - wxConvUTF7, + (const char*)welcome_utf7_iconv, + sizeof(welcome_utf7_iconv), + convUTF7, 1 ); #endif TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf7_wx, - sizeof(welcome_utf7_wx), - wxConvUTF7, + (const char*)welcome_utf7_wx, + sizeof(welcome_utf7_wx), + convUTF7, 1 ); } @@ -433,20 +444,20 @@ void MBConvTestCase::UTF7Tests() void MBConvTestCase::UTF8Tests() { TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf8, - sizeof(welcome_utf8), + (const char*)welcome_utf8, + sizeof(welcome_utf8), wxConvUTF8, 1 ); TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf8, - sizeof(welcome_utf8), + (const char*)welcome_utf8, + sizeof(welcome_utf8), wxConvUTF8, 1 ); @@ -456,20 +467,20 @@ void MBConvTestCase::UTF16LETests() { wxMBConvUTF16LE convUTF16LE; TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf16le, - sizeof(welcome_utf16le), + (const char*)welcome_utf16le, + sizeof(welcome_utf16le), convUTF16LE, 2 ); TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf16le, - sizeof(welcome_utf16le), + (const char*)welcome_utf16le, + sizeof(welcome_utf16le), convUTF16LE, 2 ); @@ -479,20 +490,20 @@ void MBConvTestCase::UTF16BETests() { wxMBConvUTF16BE convUTF16BE; TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf16be, - sizeof(welcome_utf16be), + (const char*)welcome_utf16be, + sizeof(welcome_utf16be), convUTF16BE, 2 ); TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf16be, - sizeof(welcome_utf16be), + (const char*)welcome_utf16be, + sizeof(welcome_utf16be), convUTF16BE, 2 ); @@ -502,20 +513,20 @@ void MBConvTestCase::UTF32LETests() { wxMBConvUTF32LE convUTF32LE; TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf32le, - sizeof(welcome_utf32le), + (const char*)welcome_utf32le, + sizeof(welcome_utf32le), convUTF32LE, 4 ); TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf32le, - sizeof(welcome_utf32le), + (const char*)welcome_utf32le, + sizeof(welcome_utf32le), convUTF32LE, 4 ); @@ -525,20 +536,20 @@ void MBConvTestCase::UTF32BETests() { wxMBConvUTF32BE convUTF32BE; TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf32be, - sizeof(welcome_utf32be), + (const char*)welcome_utf32be, + sizeof(welcome_utf32be), convUTF32BE, 4 ); TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_utf32be, - sizeof(welcome_utf32be), + (const char*)welcome_utf32be, + sizeof(welcome_utf32be), convUTF32BE, 4 ); @@ -548,27 +559,27 @@ void MBConvTestCase::CP932Tests() { wxCSConv convCP932( wxFONTENCODING_CP932 ); TestDecoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_cp932, - sizeof(welcome_cp932), + (const char*)welcome_cp932, + sizeof(welcome_cp932), convCP932, 1 ); TestEncoder - ( - (const wchar_t*)welcome_wchar_t, + ( + (const wchar_t*)welcome_wchar_t, sizeof(welcome_wchar_t)/sizeof(wchar_t), - (const char*)welcome_cp932, - sizeof(welcome_cp932), + (const char*)welcome_cp932, + sizeof(welcome_cp932), convCP932, 1 ); } // a character sequence encoded as iso8859-1 (iconv) -static const unsigned char iso8859_1[251] = +static const unsigned char iso8859_1[251] = { 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14, 0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24, @@ -588,7 +599,7 @@ static const unsigned char iso8859_1[251] = 0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff }; // the above character sequence encoded as UTF-8 (iconv) -static const unsigned char iso8859_1_utf8[379] = +static const unsigned char iso8859_1_utf8[379] = { 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14, 0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24, @@ -617,7 +628,7 @@ static const unsigned char iso8859_1_utf8[379] = }; // a character sequence encoded as CP1252 (iconv) -static const unsigned char CP1252[246] = +static const unsigned char CP1252[246] = { 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14, 0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24, @@ -637,7 +648,7 @@ static const unsigned char CP1252[246] = 0x85,0x89,0x8b,0x9b,0x80,0x99 }; // the above character sequence encoded as UTF-8 (iconv) -static const unsigned char CP1252_utf8[386] = +static const unsigned char CP1252_utf8[386] = { 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14, 0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24, @@ -666,8 +677,11 @@ static const unsigned char CP1252_utf8[386] = 0x84,0xa2 }; +// this is unused currently so avoid warnings about this +#if 0 + // a character sequence encoded as iso8859-5 (iconv) -static const unsigned char iso8859_5[251] = +static const unsigned char iso8859_5[251] = { 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14, 0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24, @@ -687,7 +701,7 @@ static const unsigned char iso8859_5[251] = 0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfe,0xff,0xf0 }; // the above character sequence encoded as UTF-8 (iconv) -static const unsigned char iso8859_5_utf8[380] = +static const unsigned char iso8859_5_utf8[380] = { 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14, 0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24, @@ -714,6 +728,7 @@ static const unsigned char iso8859_5_utf8[380] = 0x92,0xd1,0x93,0xd1,0x94,0xd1,0x95,0xd1,0x96,0xd1,0x97,0xd1,0x98,0xd1,0x99,0xd1, 0x9a,0xd1,0x9b,0xd1,0x9c,0xd1,0x9e,0xd1,0x9f,0xe2,0x84,0x96 }; +#endif // 0 // DecodeUTF8 // decodes the specified *unterminated* UTF-8 byte array @@ -752,24 +767,23 @@ void MBConvTestCase::TestCoder( // so we should store the wide character version as UTF-8 and depend on // the UTF-8 converter's ability to decode it to platform specific wide characters // this test is invalid if the UTF-8 converter can't decode - wxWCharBuffer wideBuffer((size_t)0); - wideBuffer = DecodeUTF8( utf8Buffer, utf8Bytes ); - size_t wideChars = wxWcslen( wideBuffer.data() ); + const wxWCharBuffer wideBuffer(DecodeUTF8(utf8Buffer, utf8Bytes)); + const size_t wideChars = wxWcslen(wideBuffer); TestDecoder - ( - wideBuffer.data(), + ( + wideBuffer.data(), wideChars, - (const char*)multiBuffer, + multiBuffer, multiBytes, converter, sizeofNull ); TestEncoder - ( - wideBuffer.data(), + ( + wideBuffer.data(), wideChars, - (const char*)multiBuffer, + multiBuffer, multiBytes, converter, sizeofNull @@ -799,6 +813,120 @@ void MBConvTestCase::FontmapTests() #endif } +void MBConvTestCase::BufSize() +{ + wxCSConv conv1251(wxT("CP1251")); + CPPUNIT_ASSERT( conv1251.IsOk() ); + const char *cp1251text = + "\313\301\326\305\324\323\321 \325\304\301\336\316\331\315"; + + const size_t lenW = conv1251.MB2WC(NULL, cp1251text, 0); + CPPUNIT_ASSERT_EQUAL( strlen(cp1251text), lenW ); + wxWCharBuffer wbuf(lenW + 1); // allocates lenW + 2 characters + wbuf.data()[lenW + 1] = L'!'; + + // lenW is not enough because it's the length and we need the size + CPPUNIT_ASSERT_EQUAL( + wxCONV_FAILED, conv1251.MB2WC(wbuf.data(), cp1251text, lenW) ); + + // lenW+1 is just fine + CPPUNIT_ASSERT( + conv1251.MB2WC(wbuf.data(), cp1251text, lenW + 1) != wxCONV_FAILED ); + + // of course, greater values work too + CPPUNIT_ASSERT( + conv1251.MB2WC(wbuf.data(), cp1251text, lenW + 2) != wxCONV_FAILED ); + + // but they shouldn't write more stuff to the buffer + CPPUNIT_ASSERT_EQUAL( L'!', wbuf[lenW + 1] ); + + + // test in the other direction too, using an encoding with multibyte NUL + wxCSConv convUTF16(wxT("UTF-16LE")); + CPPUNIT_ASSERT( convUTF16.IsOk() ); + const wchar_t *utf16text = L"Hello"; + + const size_t lenMB = convUTF16.WC2MB(NULL, utf16text, 0); + CPPUNIT_ASSERT_EQUAL( wcslen(utf16text)*2, lenMB ); + wxCharBuffer buf(lenMB + 2); // it only adds 1 for NUL on its own, we need 2 + // for NUL and an extra one for the guard byte + buf.data()[lenMB + 2] = '?'; + + CPPUNIT_ASSERT_EQUAL( + wxCONV_FAILED, convUTF16.WC2MB(buf.data(), utf16text, lenMB) ); + CPPUNIT_ASSERT_EQUAL( + wxCONV_FAILED, convUTF16.WC2MB(buf.data(), utf16text, lenMB + 1) ); + CPPUNIT_ASSERT( + convUTF16.WC2MB(buf.data(), utf16text, lenMB + 2) != wxCONV_FAILED ); + CPPUNIT_ASSERT( + convUTF16.WC2MB(buf.data(), utf16text, lenMB + 3) != wxCONV_FAILED ); + CPPUNIT_ASSERT_EQUAL( '?', buf[lenMB + 2] ); +} + +void MBConvTestCase::FromWCharTests() +{ + wxCSConv conv950("CP950"); + char mbuf[10]; + // U+4e00 is 2 bytes (0xa4 0x40) in cp950 + wchar_t wbuf[] = { 0x4e00, 0, 0x4e00, 0 }; + + // test simple ASCII text + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 0, L"a", 1)); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[0]); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( 1, conv950.FromWChar(mbuf, 1, L"a", 1)); + CPPUNIT_ASSERT_EQUAL( 'a', mbuf[0]); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[1]); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 1, L"a", 2)); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( 2, conv950.FromWChar(mbuf, 2, L"a", 2)); + CPPUNIT_ASSERT_EQUAL( 'a', mbuf[0]); + CPPUNIT_ASSERT_EQUAL( '\0', mbuf[1]); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[2]); + + // test non-ASCII text, 1 wchar -> 2 char + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 0, wbuf, 1)); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 1, wbuf, 1)); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( 2, conv950.FromWChar(mbuf, 2, wbuf, 1)); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[2]); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 2, wbuf, 2)); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( 3, conv950.FromWChar(mbuf, 3, wbuf, 2)); + CPPUNIT_ASSERT_EQUAL( '\0', mbuf[2]); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[3]); + + // test text with embedded NUL-character and srcLen specified + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 3, wbuf, 3)); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 4, wbuf, 3)); + CPPUNIT_ASSERT_EQUAL( 5, conv950.FromWChar(mbuf, 5, wbuf, 3)); + CPPUNIT_ASSERT_EQUAL( '\0', mbuf[2]); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[5]); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( wxCONV_FAILED, conv950.FromWChar(mbuf, 5, wbuf, 4)); + + memset(mbuf, '!', sizeof(mbuf)); + CPPUNIT_ASSERT_EQUAL( 6, conv950.FromWChar(mbuf, 6, wbuf, 4)); + CPPUNIT_ASSERT_EQUAL( '\0', mbuf[2]); + CPPUNIT_ASSERT_EQUAL( '\0', mbuf[5]); + CPPUNIT_ASSERT_EQUAL( '!', mbuf[6]); +} WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_iconv( const char* name ); @@ -822,6 +950,24 @@ void MBConvTestCase::IconvTests() #endif } +void MBConvTestCase::Latin1Tests() +{ + TestCoder( + (const char*)iso8859_1, + sizeof(iso8859_1), + (const char*)iso8859_1_utf8, + sizeof(iso8859_1_utf8), + wxConvISO8859_1, + 1 + ); + + static const char nulstr[] = "foo\0bar\0"; + static const size_t mbLen = WXSIZEOF(nulstr) - 1; + size_t wcLen; + wxConvISO8859_1.cMB2WC(nulstr, mbLen, &wcLen); + CPPUNIT_ASSERT_EQUAL( mbLen, wcLen ); +} + void MBConvTestCase::CP1252Tests() { wxCSConv convCP1252( wxFONTENCODING_CP1252 ); @@ -837,35 +983,23 @@ void MBConvTestCase::CP1252Tests() void MBConvTestCase::LibcTests() { - // There isn't a locale that all systems support (except "C"), so leave - // this one disabled for non-Windows systems for the moment, until - // a solution can be found. -#ifdef __WXMSW__ - -#ifdef __WXMSW__ - setlocale( LC_ALL, "English_United States.1252" ); - const unsigned char* systemMB = CP1252; - size_t systemMB_size = sizeof(CP1252); - const unsigned char* systemMB_utf8 = CP1252_utf8; - size_t systemMB_utf8_size = sizeof(CP1252_utf8); -#else - setlocale( LC_ALL, "en_US.iso8859-1" ); - const unsigned char* systemMB = iso8859_1; - size_t systemMB_size = sizeof(iso8859_1); - const unsigned char* systemMB_utf8 = iso8859_1_utf8; - size_t systemMB_utf8_size = sizeof(iso8859_1_utf8); -#endif + // The locale name are OS-dependent so this test is done only under Windows + // when using MSVC (surprisingly it fails with MinGW, even though it's + // supposed to use the same CRT -- no idea why and unfortunately gdb is too + // flaky to debug it) +#ifdef __VISUALC__ + LocaleSetter loc("English_United States.1252"); + wxMBConvLibc convLibc; TestCoder( - (const char*)systemMB, - systemMB_size, - (const char*)systemMB_utf8, - systemMB_utf8_size, - &convLibc, + (const char*)CP1252, + sizeof(CP1252), + (const char*)CP1252_utf8, + sizeof(CP1252_utf8), + convLibc, 1 ); - -#endif // __WXMSW__ +#endif // __VISUALC__ } // verifies that the specified mb sequences decode to the specified wc sequence @@ -887,13 +1021,18 @@ void MBConvTestCase::TestDecoder( // calculate the output size size_t outputWritten = converter.MB2WC - ( - 0, - (const char*)inputCopy.data(), + ( + 0, + (const char*)inputCopy.data(), 0 ); // make sure the correct output length was calculated - CPPUNIT_ASSERT( outputWritten == wideChars ); + WX_ASSERT_EQUAL_MESSAGE + ( + ("while converting \"%s\"", multiBuffer), + wideChars, + outputWritten + ); // convert the string size_t guardChars = 8; // to make sure we're not overrunning the output buffer @@ -903,13 +1042,13 @@ void MBConvTestCase::TestDecoder( memset( outputBuffer.data(), UNINITIALIZED, outputBufferChars*sizeof(wchar_t) ); outputWritten = converter.MB2WC - ( - outputBuffer.data(), - (const char*)inputCopy.data(), + ( + outputBuffer.data(), + (const char*)inputCopy.data(), outputBufferChars ); // make sure the correct number of characters were outputs - CPPUNIT_ASSERT( outputWritten == wideChars ); + CPPUNIT_ASSERT_EQUAL( wideChars, outputWritten ); // make sure the characters generated are correct CPPUNIT_ASSERT( 0 == memcmp( outputBuffer, wideBuffer, wideChars*sizeof(wchar_t) ) ); @@ -947,13 +1086,13 @@ void MBConvTestCase::TestEncoder( // calculate the output size size_t outputWritten = converter.WC2MB - ( - 0, - (const wchar_t*)inputCopy.data(), + ( + 0, + (const wchar_t*)inputCopy.data(), 0 ); // make sure the correct output length was calculated - CPPUNIT_ASSERT( outputWritten == multiBytes ); + CPPUNIT_ASSERT_EQUAL( multiBytes, outputWritten ); // convert the string size_t guardBytes = 8; // to make sure we're not overrunning the output buffer @@ -962,14 +1101,14 @@ void MBConvTestCase::TestEncoder( memset( outputBuffer.data(), UNINITIALIZED, outputBufferSize ); outputWritten = converter.WC2MB - ( - outputBuffer.data(), - (const wchar_t*)inputCopy.data(), - outputBufferSize + ( + outputBuffer.data(), + (const wchar_t*)inputCopy.data(), + outputBufferSize ); // make sure the correct number of characters were output - CPPUNIT_ASSERT( outputWritten == multiBytes ); + CPPUNIT_ASSERT_EQUAL( multiBytes, outputWritten ); // make sure the characters generated are correct CPPUNIT_ASSERT( 0 == memcmp( outputBuffer, multiBuffer, multiBytes ) ); @@ -1012,7 +1151,11 @@ void MBConvTestCase::TestStreamDecoder( for ( size_t i = 0; i < wideChars; i++ ) { wxChar wc = textInputStream.GetChar(); - CPPUNIT_ASSERT( wc == wideBuffer[i] ); + CPPUNIT_ASSERT_EQUAL_MESSAGE( + std::string(wxString::Format("At position %lu", (unsigned long)i)), + wideBuffer[i], + wc + ); } CPPUNIT_ASSERT( 0 == textInputStream.GetChar() ); CPPUNIT_ASSERT( memoryInputStream.Eof() ); @@ -1040,7 +1183,10 @@ void MBConvTestCase::TestStreamEncoder( { textOutputStream.PutChar( wideBuffer[i] ); } - CPPUNIT_ASSERT_EQUAL( (wxFileOffset)multiBytes, memoryOutputStream.TellO() ); + + textOutputStream.Flush(); + + CPPUNIT_ASSERT_EQUAL( multiBytes, size_t(memoryOutputStream.TellO()) ); wxCharBuffer copy( memoryOutputStream.TellO() ); memoryOutputStream.CopyTo( copy.data(), memoryOutputStream.TellO()); CPPUNIT_ASSERT_EQUAL( 0, memcmp( copy.data(), multiBuffer, multiBytes ) ); @@ -1093,7 +1239,7 @@ void MBConvTestCase::UTF8Octal(const char *charSequence, // static wchar_t *wx_wcscpy(wchar_t *dest, const wchar_t *src) { - wchar_t *d = dest; + wchar_t *d = dest; while ((*d++ = *src++) != 0) ; return dest; @@ -1103,7 +1249,7 @@ static wchar_t *wx_wcscpy(wchar_t *dest, const wchar_t *src) // static wchar_t *wx_wcscat(wchar_t *dest, const wchar_t *src) { - wchar_t *d = dest; + wchar_t *d = dest; while (*d) d++; while ((*d++ = *src++) != 0) @@ -1146,12 +1292,12 @@ void MBConvTestCase::UTF8(const char *charSequence, const size_t BUFSIZE = 128; wxASSERT(strlen(charSequence) * 3 + 10 < BUFSIZE); char bytes[BUFSIZE]; - + // include the option in the error messages so it's possible to see // which test failed sprintf(bytes, " (with option == %d)", option); std::string errmsg(bytes); - + // put the charSequence at the start, middle and end of a string strcpy(bytes, charSequence); strcat(bytes, "ABC");