Symaptic: os/textandloc/charconvfw/charconvplugins/test/rtest/tsrc/main/t

     1 /*

     2 * Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    19 #include <e32std.h>

    20 #include <e32base.h>

    21 #include <f32file.h>

    22 #include <charconv.h>

    23 #include "t_gb18030.h"

    24 #define test(cond)                                  \

    25     {                                               \

    26     TBool __bb = (cond);                            \

    27     TEST(__bb);                                     \

    28     if (!__bb)                                      \

    29         {                                           \

    30         ERR_PRINTF1(_L("ERROR: Test Failed"));      \

    31         User::Leave(1);                             \

    32         }                                           \

    33     }

    35 const TInt KMibValue = 114;

    36 const TInt KBufferLength=100;

    38 void CT_GB18030::TestTruncatedConversionFromUnicodeToGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode)

    39 	{

    40 	for (TInt i=aOriginalUnicode.Length(); i>=0; --i)

    41 		{

    42 		TBuf8<KBufferLength> generatedGb18030;

    43 		const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedGb18030, aOriginalUnicode.Left(i));

    44 		test(returnValue>=0);

    45 		TBuf8<KBufferLength> generatedsecondPartOfGb18030;

    46 		test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfGb18030, aOriginalUnicode.Mid(i-returnValue))==0);

    47 		generatedGb18030.Append(generatedsecondPartOfGb18030);

    48 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    49 		TBuf16<KBufferLength> generatedUnicode;

    50 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedGb18030, state)==0);

    51 		test(generatedUnicode==aOriginalUnicode);

    52 		}

    53 	}

    55 void CT_GB18030::TestSplittingConvertingFromUnicodeToGb18030(CCnvCharacterSetConverter& aCharacterSetConverter,

    56 		TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit,

    57 		TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfGb18030,

    58 		const TDesC8& aExpectedGb18030, const TDesC16& aOriginalUnicode)

    59 	{

    60 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

    61 	test(aMaximumLengthUpperLimit<=KBufferLength);

    62 	TUint8 gb18030Buffer[KBufferLength];

    63 	for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i)

    64 		{

    65 		TPtr8 generatedFirstPartOfGb18030(gb18030Buffer, i);

    66 		test(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfGb18030, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit);

    67 		test(generatedFirstPartOfGb18030==aExpectedGb18030.Left(aExpectedLengthOfFirstPartOfGb18030));

    68 		TBuf8<KBufferLength> generatedSecondPartOfGb18030;

    69 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGb18030, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0);

    70 		test(generatedSecondPartOfGb18030==aExpectedGb18030.Mid(aExpectedLengthOfFirstPartOfGb18030));

    71 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    72 		TBuf16<KBufferLength> generatedUnicode;

    73 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfGb18030, state)==0);

    74 		test(state==CCnvCharacterSetConverter::KStateDefault);

    75 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

    76 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfGb18030, state)==0);

    77 		test(state==CCnvCharacterSetConverter::KStateDefault);

    78 		generatedUnicode.Append(generatedSecondPartOfUnicode);

    79 		test(generatedUnicode==aOriginalUnicode);

    80 		}

    81 	}

    83 void CT_GB18030::TestTruncatedConversionToUnicodeFromGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGb18030)

    84 	{

    85 	for (TInt i=aOriginalGb18030.Length(); i>=4; --i) // 4 is the length of GB18030's longest multi-byte characters

    86 		{

    87 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    88 		TBuf16<KBufferLength> generatedUnicode;

    89 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalGb18030.Left(i), state);

    90 		test(returnValue>=0);

    91 		TBuf16<KBufferLength> generatedsecondPartOfUnicode;

    92 		test(aCharacterSetConverter.ConvertToUnicode(generatedsecondPartOfUnicode, aOriginalGb18030.Mid(i-returnValue), state)==0);

    93 		generatedUnicode.Append(generatedsecondPartOfUnicode);

    94 		test(generatedUnicode==aExpectedUnicode);

    95 		}

    96 	}

    98 void CT_GB18030::TestSplittingConvertingToUnicodeFromGb18030(CCnvCharacterSetConverter& aCharacterSetConverter,

   100 				TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit,

   101 				TInt aExpectedNumberOfGb18030BytesNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfUnicode,

   102 				const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGb18030)

   103 	{

   104 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

   105 	test(aMaximumLengthUpperLimit<=KBufferLength);

   106 	TUint16 unicodeBuffer[KBufferLength];

   107 	for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i)

   108 		{

   109 		TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i);

   110 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   111 		test(aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalGb18030, state)==aExpectedNumberOfGb18030BytesNotConvertedAtSplit);

   112 		test(generatedFirstPartOfUnicode==aExpectedUnicode.Left(aExpectedLengthOfFirstPartOfUnicode));

   113 		test(state==CCnvCharacterSetConverter::KStateDefault);

   114 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

   115 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalGb18030.Right(aExpectedNumberOfGb18030BytesNotConvertedAtSplit), state)==0);

   116 		test(generatedSecondPartOfUnicode==aExpectedUnicode.Mid(aExpectedLengthOfFirstPartOfUnicode));

   117 		test(state==CCnvCharacterSetConverter::KStateDefault);

   118 		TBuf8<KBufferLength> generatedGb18030;

   119 		test(aCharacterSetConverter.ConvertFromUnicode(generatedGb18030, generatedFirstPartOfUnicode)==0);

   120 		TBuf8<KBufferLength> generatedSecondPartOfGb18030;

   121 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGb18030, generatedSecondPartOfUnicode)==0);

   122 		generatedGb18030.Append(generatedSecondPartOfGb18030);

   123 		test(generatedGb18030==aOriginalGb18030);

   124 		}

   125 	}

   128 void CT_GB18030::CharacterSetValueAndMIBTests(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession)

   129 {

   130 	// check that the character set value of '114' is converted to the GB18030 UID (0x10287038)

   131 	test(aCharacterSetConverter.ConvertMibEnumOfCharacterSetToIdentifierL(KMibValue,aFileServerSession)==KCharacterSetIdentifierGb18030);

   132 	INFO_PRINTF1(_L("\nMIB->Char Set UID - OK"));

   134 	// check that the UCS2 GUID (0x10287038) is converted to the character set value of '114'

   135 	test(aCharacterSetConverter.ConvertCharacterSetIdentifierToMibEnumL(KCharacterSetIdentifierGb18030,aFileServerSession)==KMibValue);

   136 	INFO_PRINTF1(_L("\nChar Set UID->MIB - OK"));

   137 }

   140 /**

   141 */

   142 void CT_GB18030::TestConversionToUnicodeFromGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGb18030, TInt aExpectedResult)

   143 	{

   144 	TInt state=CCnvCharacterSetConverter::KStateDefault;

   145 	TBuf16<KBufferLength> generatedUnicode;

   146 	const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalGb18030, state);

   147 	test(returnValue == aExpectedResult );

   148 	test(generatedUnicode==aExpectedUnicode);

   149 	}

   152 /**

   153 */

   154 void CT_GB18030::TestConversionFromUnicodeToGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode, TInt aExpectedResult)

   155 	{

   156 	TBuf8<KBufferLength> generatedGb18030;

   157 	const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedGb18030, aOriginalUnicode);

   158 	test(returnValue == aExpectedResult);

   159 	TInt state=CCnvCharacterSetConverter::KStateDefault;

   160 	TBuf16<KBufferLength> generatedUnicode;

   161 	test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedGb18030, state)==0);

   162 	test(generatedUnicode==aOriginalUnicode);

   163 	}

   165 /**

   166 @SYMTestCaseID          TI18N-CHARCONV-CT-4051

   167 @SYMTestCaseDesc        Check GB18030 plugin support  conversion between one byte GB18030 character and Unicode

   168 @SYMTestPriority        High

   169 @SYMTestActions         1. Select characters from one-byte character set of GB2312-80

   170 						2. Pass it to charconv and convert it to Unicode

   171 						3. Pass the above Unicode to charconv and convert it to GB18030

   172 @SYMTestExpectedResults Conversion is successful, and the returned Unicode/GB18030 is as defined

   173 @SYMREQ                 REQ12065 PREQ12066

   174 */

   176 void CT_GB18030::OneByteConversion( CCnvCharacterSetConverter& aCharacterSetConverter )

   177 {

   178 	TPtrC8 originalGb18030;

   179 	TBuf16<KBufferLength> originalUnicode;

   181 	//	One-byte gb

   182 	originalGb18030.Set(_L8("\x40"));

   183 	originalUnicode.Format(_L16("%c"), 0x40);

   185 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   186 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   188 	//	one-byte uincode

   189 	_LIT16(Uni_0, "\x0000");

   190 	_LIT8(Gb_0, "\x00");

   191 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_0);

   192 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_0, Gb_0);

   194 	_LIT16(Uni_1, "\x0079");

   195 	_LIT8(Gb_1, "\x79");

   196 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_1);

   197 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_1, Gb_1);

   199 	_LIT16(Uni_2, "\x0080");

   200 	_LIT8(Gb_2, "\x81\x30\x81\x30");

   201 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_2);

   202 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_2, Gb_2);

   204 	_LIT16(Uni_3, "\x0081");

   205 	_LIT8(Gb_3, "\x81\x30\x81\x31");

   206 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_3);

   207 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_3, Gb_3);

   209 	_LIT16(Uni_4, "\x00fe");

   210 	_LIT8(Gb_4, "\x81\x30\x8B\x36");

   211 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_4);

   212 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_4, Gb_4);

   214 	_LIT16(Uni_5, "\x00ff");

   215 	_LIT8(Gb_5, "\x81\x30\x8B\x37");

   216 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_5);

   217 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_5, Gb_5);

   218 }

   221 /**

   222 @SYMTestCaseID          TI18N-CHARCONV-CT-4052

   223 @SYMTestCaseDesc        Check GB18030 plug-in support  conversion between two-byte GB18030 character and Unicode

   224 @SYMTestPriority        High

   225 @SYMTestActions         1. Select characters from two-byte character set from GB2312-80

   226 						2. Pass it to charconv and convert it to Unicode

   227 						3. Pass the above Unicode to charconv and convert it to GB18030

   228 						4. Select characters from two-byte characters set from GBK, outside of GB2312-80, same with GBK

   229 						5. Pass to charconv and convert to Unicode

   230 						6. Pass the above Unicode to charconv, and conver it to GB18030

   231 						7. Select characters from two-byte characters set from GBK, outside of GB2312-80, different from GBK

   232 						8. Pass to charconv and convert to Unicode

   233 						9. Pass the above Unicode to charconv, and conver it to GB18030

   234 @SYMTestExpectedResults Conversion is successful, and the returned Unicode/GB18030 is as defined

   235 @SYMREQ                 REQ12065 REQ12066

   236 */

   238 void CT_GB18030::TwoByteConversion( CCnvCharacterSetConverter& aCharacterSetConverter )

   239 {

   240 	TPtrC8 originalGb18030;

   241 	TBuf16<KBufferLength> originalUnicode;

   243 	//	two-byte gb

   244 	originalGb18030.Set(_L8("\xec\xe1"));

   245 	originalUnicode.Format(_L16("%c"), 0x706c);

   246 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   247 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   249 	originalGb18030.Set(_L8("\x81\x81"));

   250 	originalUnicode.Format(_L16("%c"), 0x4e96);

   251 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   252 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   254 	originalGb18030.Set(_L8("\xa2\xe3"));

   255 	originalUnicode.Format(_L16("%c"), 0x20ac);

   256 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   257 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   258 	originalGb18030.Set(_L8("\xa6\xd9"));

   259 	originalUnicode.Format(_L16("%c"), 0xe78d);

   260 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   261 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   262 	originalGb18030.Set(_L8("\xa8\xbc"));

   263 	originalUnicode.Format(_L16("%c"), 0x1e3f);

   264 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   265 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   268 	//	two-byte unicode

   269 	_LIT16(Uni_6, "\x0100");

   270 	_LIT8(Gb_6, "\x81\x30\x8B\x38");

   271 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_6);

   272 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_6, Gb_6);

   274 	_LIT16(Uni_7, "\x0101");

   275 	_LIT8(Gb_7, "\xA8\xA1");

   276 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_7);

   277 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_7, Gb_7);

   279 	_LIT16(Uni_8, "\x0ffe");

   280 	_LIT8(Gb_8, "\x81\x33\x83\x38");

   281 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_8);

   282 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_8, Gb_8);

   284 	_LIT16(Uni_9, "\x0fff");

   285 	_LIT8(Gb_9, "\x81\x33\x83\x39");

   286 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_9);

   287 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_9, Gb_9);

   289 	_LIT16(Uni_10, "\x1000");

   290 	_LIT8(Gb_10, "\x81\x33\x84\x30");

   291 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_10);

   292 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_10, Gb_10);

   294 	_LIT16(Uni_11, "\x1001");

   295 	_LIT8(Gb_11, "\x81\x33\x84\x31");

   296 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_11);

   297 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_11, Gb_11);

   299 	_LIT16(Uni_12, "\xfffe");

   300 	_LIT8(Gb_12, "\x84\x31\xA4\x38");

   301 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_12);

   302 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_12, Gb_12);

   304 	_LIT16(Uni_13, "\xffff");

   305 	_LIT8(Gb_13, "\x84\x31\xA4\x39");

   306 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_13);

   307 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_13, Gb_13);

   308 }

   310 /**

   311 @SYMTestCaseID          TI18N-CHARCONV-CT-4056

   312 @SYMTestCaseDesc        Check GB18030 plug-in support  conversion between four-byte GB18030 character and Unicode

   313 @SYMTestPriority        High

   314 @SYMTestActions         1. Select characters from CJK A

   315 						2. Pass it to charconv and convert it to Unicode

   316 						3. Pass the above Unicode to charconv and convert it to GB18030

   317 						4. Select characters from CJK B

   318 						5. Pass it to charconv and convert it to Unicode

   319 						6. Pass the above Unicode to charconv and convert it to GB18030

   320 @SYMTestExpectedResults Conversion is successful, and the returned Unicode/GB18030 is as defined

   321 @SYMREQ                 REQ12065 REQ12066

   322 */

   324 void CT_GB18030::FourByteConversion( CCnvCharacterSetConverter& aCharacterSetConverter )

   325 {

   326 	TPtrC8 originalGb18030;

   327 	TBuf16<KBufferLength> originalUnicode;

   329 	//	four-byte gb

   330 	originalGb18030.Set(_L8("\x82\x30\xA7\x30"));

   331 	originalUnicode.Format(_L16("%c"), 0x3622);

   332 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   333 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   335 	originalGb18030.Set(_L8("\x95\x32\xad\x35"));

   336 	originalUnicode.Format(_L16("%c%c"), 0xd840, 0xddad );//0x201ad)

   337 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   338 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   340 	//	four-byte unicode

   341 	_LIT16(Uni_14, "\xd840\xdc00");

   342 	_LIT8(gb_14, "\x95\x32\x82\x36");

   343 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_14);

   344 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_14, gb_14);

   346 	_LIT16(Uni_15, "\xd840\xdc01");

   347 	_LIT8(gb_15, "\x95\x32\x82\x37");

   348 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_15);

   349 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_15, gb_15);

   351 	_LIT16(Uni_16, "\xD87F\xdffe");

   352 	_LIT8(gb_16, "\x9a\x34\x84\x30");

   353 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_16);

   354 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_16, gb_16);

   356 	_LIT16(Uni_17, "\xD87F\xdfff");

   357 	_LIT8(gb_17, "\x9a\x34\x84\x31");

   358 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_17);

   359 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_17, gb_17);

   360 }

   363 /**

   364 @SYMTestCaseID          TI18N-CHARCONV-CT-4054

   365 @SYMTestCaseDesc        Check GB18030 plug-in support  conversion between one-byte GB18030 character and Unicode, negative input

   366 @SYMTestPriority        High

   367 @SYMTestActions         1. Select one-byte characters which are not mapped to Unicode

   368 						2. Pass it to charconv and convert it to Unicode

   369 						3. Select one-byte code point which is not valid in GB18030

   370 						4. Pass it to charconv and convert it to Unicode

   371 @SYMTestExpectedResults No side effect

   372 @SYMREQ                 REQ12065 REQ12066

   373 */

   375 void CT_GB18030::OneByteConversionNegative( CCnvCharacterSetConverter& aCharacterSetConverter )

   376 {

   377 	TPtrC8 originalGb18030;

   378 	TBuf16<KBufferLength> originalUnicode;

   380 	originalGb18030.Set(_L8("\x0e"));

   381 	originalUnicode.Format(_L16("%c"), 0x0e);

   382 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   383 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);

   385 	originalGb18030.Set(_L8("\xa0"));

   386 	originalUnicode.Copy( _L("") );

   387 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   388 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030, CCnvCharacterSetConverter::EErrorIllFormedInput );

   389 }

   392 /**

   393 @SYMTestCaseID          TI18N-CHARCONV-CT-4055

   394 @SYMTestCaseDesc        Check GB18030 plug-in support  conversion between two-byte GB18030 character and Unicode, negative input

   395 @SYMTestPriority        High

   396 @SYMTestActions         1. Select two-byte characters which are not mapped to Unicode

   397 						2. Pass it to charconv and convert it to Unicode

   398 						3. Select two-byte code points which are not valid in GB18030

   399 						4. Pass it to charconv and convert it to Unicode

   400 @SYMTestExpectedResults No side effect

   401 @SYMREQ                 REQ12065 REQ12066

   402 */

   404 void CT_GB18030::TwoByteConversionNegative( CCnvCharacterSetConverter& aCharacterSetConverter )

   405 {

   406 	TPtrC8 originalGb18030;

   407 	TBuf16<KBufferLength> originalUnicode;

   409 	originalGb18030.Set(_L8("\xa0\x7f"));

   410 	originalUnicode.Copy( _L("") );

   411 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   412 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030, CCnvCharacterSetConverter::EErrorIllFormedInput );

   413 }

   416 /**

   417 @SYMTestCaseID          TI18N-CHARCONV-CT-4056

   418 @SYMTestCaseDesc        Check GB18030 plug-in support  conversion between four-byte GB18030 character and Unicode, negative input

   419 @SYMTestPriority        High

   420 @SYMTestActions         1. Select four-byte characters which are not mapped to Unicode

   421 						2. Pass it to charconv and convert it to Unicode

   422 						3. Select four-byte code points which are not valid in GB18030

   423 						4. Pass it to charconv and convert it to Unicode

   424 @SYMTestExpectedResults No side effect

   425 @SYMREQ                 REQ12065 REQ12066

   426 */

   428 void CT_GB18030::FourByteConversionNegative( CCnvCharacterSetConverter& aCharacterSetConverter )

   429 {

   430 	TPtrC8 originalGb18030;

   431 	TBuf16<KBufferLength> originalUnicode;

   433 	originalGb18030.Set(_L8("\x81\x30\x81\x3a"));

   434 	originalUnicode.Copy( _L("") );

   435 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   436 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030, CCnvCharacterSetConverter::EErrorIllFormedInput );

   437 }

   440 /**

   441 @SYMTestCaseID          TI18N-CHARCONV-CT-4053

   442 @SYMTestCaseDesc        Check GB18030 plug-in support  conversion between problematic GB18030 character and Unicode, negative input

   443 @SYMTestPriority        High

   444 @SYMTestActions         1. Select characters whose trailing byte is in the range of leading bytes

   445 						2. Pass it to charconv and convert it to Unicode

   446 						3. Select Unicode whose leading/trailing byte is in the range of low-ANSI

   447 						4. Pass it to charconv and convert it to GB18030

   448 						5. Select characters whose trailing byte is special symbol like backslash

   449 						6. Pass it to charconv and convert it to Unicode

   450 @SYMTestExpectedResults No side effect

   451 @SYMREQ                 REQ12065 REQ12066

   452 */

   454 void CT_GB18030::ProblemProneCharcters( CCnvCharacterSetConverter& aCharacterSetConverter )

   455 {

   456 	TPtrC8 originalGb18030;

   457 	TBuf16<KBufferLength> originalUnicode;

   459 	originalGb18030.Set(_L8("\x81\x81\xba\xba\xa0\xa0\xf7\xf7"));

   460 	originalUnicode.Format(_L16("%c%c%c%c"), 0x4e96, 0x6c49, 0x724b, 0x9f22);

   461 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   462 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );

   464 	originalGb18030.Set(_L8("\xc4\x40\x83\xa0\xa0\x7c\xa0\x86"));

   465 	originalUnicode.Format(_L16("%c%c%c%c"), 0x8140, 0x512c, 0x7218, 0x7222);

   466 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   467 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );

   469 	originalGb18030.Set(_L8("\x81\x43\x81\x63\xf7\x4d\xf7\x6d\xa0\x53\xa0\x73"));

   470 	originalUnicode.Format(_L16("%c%c%c%c%c%c"), 0x4E06, 0x4E67, 0x9C49, 0x9C69, 0x71EC, 0x720F);

   471 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   472 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );

   474 	originalGb18030.Set(_L8("\x9f\xaa\x81\xae\xf7\xbf\xbf\xaa\xb0\x5b\xb1\x5b\xb1\x5c\xb2\x5c\xb2\x5d\xc3\x5d\xd4\x5f\xe5\x5f\xd6\x7b\xe7\x7b\xF7\x7C\xFD\x7C\xAA\x7D\xFE\x7D"));

   475 	originalUnicode.Format(_L16("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c"), 0x716A, 0x4F04, 0x9ABA, 0x5F00, 0x7667, 0x76F5, 0x76F6, 0x7788, 0x7789, 0x80C5, 0x8a3D, 0x9329, 0x8B20, 0x940A, 0x9C78, 0x9F76, 0x7347, 0x464c);

   476 	TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);

   477 	TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );

   478 }

   481 void CT_GB18030::DoE32MainL()

   482 	{

   483 	RFs fileServerSession;

   484 	CleanupClosePushL(fileServerSession);

   485 	User::LeaveIfError(fileServerSession.Connect());

   486 	CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC();

   487 	CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(fileServerSession);

   488 	INFO_PRINTF1(_L("Available:\n"));

   489 	for (TInt i=arrayOfCharacterSetsAvailable->Count()-1; i>=0; --i)

   490 		{

   491 		const CCnvCharacterSetConverter::SCharacterSet& charactersSet=(*arrayOfCharacterSetsAvailable)[i];

   492 		characterSetConverter->PrepareToConvertToOrFromL(charactersSet.Identifier(), *arrayOfCharacterSetsAvailable, fileServerSession);

   493 		TPtrC charactersSetName(charactersSet.Name());

   494 		if (charactersSet.NameIsFileName())

   495 			{

   496 			charactersSetName.Set(TParsePtrC(charactersSetName).Name());

   497 			}

   498 		INFO_PRINTF2(_L("    %S\n"), &charactersSetName);

   499 		}

   500 	TPtrC8 originalGb18030;

   501 	TBuf16<KBufferLength> originalUnicode;

   502 	TBuf8<KBufferLength> generatedGb18030;

   503 	TBuf16<KBufferLength> generatedUnicode;

   504 	TInt state=CCnvCharacterSetConverter::KStateDefault;

   506 	// test that we can get MIB and Charset values

   507 	CharacterSetValueAndMIBTests(*characterSetConverter, fileServerSession);

   509 	characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierGb18030, *arrayOfCharacterSetsAvailable, fileServerSession);

   511 	INFO_PRINTF1( _L("GB18030 one byte support") );

   512 	OneByteConversion( *characterSetConverter );

   514 	INFO_PRINTF1( _L("GB18030 two byte support") );

   515 	TwoByteConversion( *characterSetConverter );

   517 	INFO_PRINTF1( _L("GB18030 four byte support") );

   518 	FourByteConversion( *characterSetConverter );

   520 	INFO_PRINTF1( _L("GB18030 one byte support with negative input") );

   521 	OneByteConversionNegative( *characterSetConverter );

   523 	INFO_PRINTF1( _L("GB18030 two byte support with negative input") );

   524 	TwoByteConversionNegative( *characterSetConverter );

   526 	INFO_PRINTF1( _L("GB18030 four byte support with negative input") );

   527 	FourByteConversionNegative( *characterSetConverter );

   529 	INFO_PRINTF1( _L("Problem prone characters") );

   530 	ProblemProneCharcters( *characterSetConverter );

   532 	INFO_PRINTF1(_L("Testing characters shared with GB 2312-80 and characters only in GBK"));

   534 	originalGb18030.Set(_L8("A\xfd\x7d\xdd\xb6\xb1\xc9\xe9\x8e\xe8\x9d""E b\xd3\x59\xd2\x40\x95\xc0"));		// 20 byte, 12 char

   535 	originalUnicode.Format(_L16("A%c%c%c%c%cE b%c%c%c"), 0x9f77, 0x837b, 0x9119, 0x95b9, 0x94e6, 0x89bb, 0x8938, 0x66b2);

   536 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   537 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 12, 0, originalGb18030, originalUnicode);

   538 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 2, 11, 1, originalGb18030, originalUnicode);

   539 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 3, 4, 10, 3, originalGb18030, originalUnicode);

   540 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 5, 6, 9, 5, originalGb18030, originalUnicode);

   541 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 7, 8, 8, 7, originalGb18030, originalUnicode);

   542 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 9, 10, 7, 9, originalGb18030, originalUnicode);

   543 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 11, 11, 6, 11, originalGb18030, originalUnicode);

   544 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 12, 12, 5, 12, originalGb18030, originalUnicode);

   545 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 13, 13, 4, 13, originalGb18030, originalUnicode);

   546 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 14, 15, 3, 14, originalGb18030, originalUnicode);

   547 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 16, 17, 2, 16, originalGb18030, originalUnicode);

   548 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 18, 19, 1, 18, originalGb18030, originalUnicode);

   549 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 20, 40, 0, 20, originalGb18030, originalUnicode);

   550 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   551 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(1, 2), originalGb18030.Mid(1, 4));

   552 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 20, 0, originalUnicode, originalGb18030);

   553 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 19, 1, originalUnicode, originalGb18030);

   554 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 17, 2, originalUnicode, originalGb18030);

   555 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 15, 3, originalUnicode, originalGb18030);

   556 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 4, 13, 4, originalUnicode, originalGb18030);

   557 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 5, 5, 11, 5, originalUnicode, originalGb18030);

   558 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 6, 6, 9, 6, originalUnicode, originalGb18030);

   559 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 7, 7, 8, 7, originalUnicode, originalGb18030);

   560 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 8, 8, 7, 8, originalUnicode, originalGb18030);

   561 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 9, 9, 6, 9, originalUnicode, originalGb18030);

   562 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 10, 10, 4, 10, originalUnicode, originalGb18030);

   563 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 11, 11, 2, 11, originalUnicode, originalGb18030);

   564 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 12, 30, 0, 12, originalUnicode, originalGb18030);

   566 	INFO_PRINTF1(_L("Testing GB18030 characters where the first byte has the high-bit set and the second byte doesn't"));

   567 	originalGb18030.Set(_L8("\x20\x5d\xa0\x5d\xa0\xdd"));

   568 	originalUnicode.Format(_L16(" ]%c%c"), 0x71f7, 0x72a6);

   569 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   570 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 4, 0, originalGb18030, originalUnicode);

   571 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 1, 3, 1, originalGb18030, originalUnicode);

   572 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 2, 2, originalGb18030, originalUnicode);

   573 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 1, 4, originalGb18030, originalUnicode);

   574 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 6, 20, 0, 6, originalGb18030, originalUnicode);

   575 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   576 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 6, 0, originalUnicode, originalGb18030);

   577 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 5, 1, originalUnicode, originalGb18030);

   578 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 4, 2, originalUnicode, originalGb18030);

   579 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 2, 3, originalUnicode, originalGb18030);

   580 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 20, 0, 4, originalUnicode, originalGb18030);

   582 	INFO_PRINTF1(_L("Testing truncated GB18030 sequences"));

   583 	originalGb18030.Set(_L8("qwe\xb5"));

   584 	test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGb18030, state)==1);

   585 	test(state==CCnvCharacterSetConverter::KStateDefault);

   586 	test(generatedUnicode==_L16("qwe"));

   588 	originalGb18030.Set(_L8("qwe\x81\x30"));

   589 	test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGb18030, state)==2);

   590 	test(state==CCnvCharacterSetConverter::KStateDefault);

   591 	test(generatedUnicode==_L16("qwe"));

   593 	INFO_PRINTF1(_L("Testing 4 byte characters, including surrogate pair"));

   594 	originalGb18030.Set(_L8("C\x81\x30\x81\x30\x82\x30\x81\x30\x95\x32\x82\x36"));		// 13 byte

   595 	originalUnicode.Format(_L16("C%c%c%c%c"), 0x0080, 0x34A3, 0xD840, 0xDC00);			// 4 Char (3 UCS2, 1 surrogate pair)

   596 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   597 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 5, 0, originalGb18030, originalUnicode);

   598 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 4, 4, 1, originalGb18030, originalUnicode);

   599 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 5, 8, 3, 5, originalGb18030, originalUnicode);

   600 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 9, 12, 2, 9, originalGb18030, originalUnicode);

   601 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 13, 40, 0, 13, originalGb18030, originalUnicode);

   602 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   603 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(1, 2), originalGb18030.Mid(1, 8));

   604 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(3, 2), originalGb18030.Mid(9, 4));

   605 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 13, 0, originalUnicode, originalGb18030);

   606 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 12, 1, originalUnicode, originalGb18030);

   607 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 8, 2, originalUnicode, originalGb18030);

   608 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 4, 4, 3, originalUnicode, originalGb18030);

   609 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 5, 30, 0, 5, originalUnicode, originalGb18030);

   611 	INFO_PRINTF1(_L("Testing GB18030 characters which have different mapping with GB2312-80"));

   612 	originalGb18030.Set(_L8("\xa1\xaa\xa1\xa4\xa8\x44\x81\x39\xa7\x39"));		// 10 byte

   613 	originalUnicode.Format(_L16("%c%c%c%c"), 0x2014, 0x00B7, 0x2015, 0x30FB);			// 4 char (UCS2)

   614 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   615 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 1, 4, 0, originalGb18030, originalUnicode);

   616 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 3, 2, originalGb18030, originalUnicode);

   617 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 2, 4, originalGb18030, originalUnicode);

   618 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 6, 9, 1, 6, originalGb18030, originalUnicode);

   619 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 20, 0, 10, originalGb18030, originalUnicode);

   620 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   621 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 2), originalGb18030.Mid(0, 4));

   622 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(2, 2), originalGb18030.Mid(4, 6));

   623 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 10, 0, originalUnicode, originalGb18030);

   624 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 8, 1, originalUnicode, originalGb18030);

   625 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 6, 2, originalUnicode, originalGb18030);

   626 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 4, 3, originalUnicode, originalGb18030);

   627 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 10, 0, 4, originalUnicode, originalGb18030);

   629 	INFO_PRINTF1(_L("Testing 2 byte GB18030 characters which have different mapping with GBK"));

   630 	originalGb18030.Set(_L8("\xa1\xa4\xa1\xaa\xa8\xbc\xa8\xbf\xa9\x8a"));		// 10 byte

   631 	originalUnicode.Format(_L16("%c%c%c%c%c"), 0x00b7, 0x2014, 0x1e3f, 0x01f9, 0x2ff0);			// 5 char (UCS2)

   632 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   633 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 1, 5, 0, originalGb18030, originalUnicode);

   634 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 4, 2, originalGb18030, originalUnicode);

   635 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 3, 4, originalGb18030, originalUnicode);

   636 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 20, 0, 10, originalGb18030, originalUnicode);

   637 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   638 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 2), originalGb18030.Mid(0, 4));

   639 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(2, 3), originalGb18030.Mid(4, 6));

   640 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 10, 0, originalUnicode, originalGb18030);

   641 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 8, 1, originalUnicode, originalGb18030);

   642 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 6, 2, originalUnicode, originalGb18030);

   643 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 5, 10, 0, 5, originalUnicode, originalGb18030);

   645 	INFO_PRINTF1(_L("Testing 2/4 byte GB18030 characters mapping to PUA codes"));

   646 	originalGb18030.Set(_L8("\xFE\xFE\xFE\xD4\xFD\xE8\xA7\xFE\xA3\xEB\x84\x31\xA4\x39\x83\x36\xF0\x37\xA3\xB1"));		// 20 byte

   647 	originalUnicode.Format(_L16("%c%c%c%c%c%c%c%c"), 0xE4C5, 0xE49B, 0xE451, 0xE7BB, 0xFF4B, 0xFFFF, 0xE9AC, 0xFF11);		// 8 char (UCS2)

   648 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   649 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 1, 8, 0, originalGb18030, originalUnicode);

   650 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 7, 2, originalGb18030, originalUnicode);

   651 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 6, 4, originalGb18030, originalUnicode);

   652 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 13, 3, 10, originalGb18030, originalUnicode);

   653 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 14, 17, 2, 14, originalGb18030, originalUnicode);

   654 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 18, 19, 1, 18, originalGb18030, originalUnicode);

   655 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 20, 40, 0, 20, originalGb18030, originalUnicode);

   656 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   657 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 2), originalGb18030.Mid(0, 4));

   658 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(2, 3), originalGb18030.Mid(4, 6));

   659 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(5, 2), originalGb18030.Mid(10, 8));

   660 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(7, 1), originalGb18030.Mid(18, 2));

   661 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 20, 0, originalUnicode, originalGb18030);

   662 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 18, 1, originalUnicode, originalGb18030);

   663 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 16, 2, originalUnicode, originalGb18030);

   664 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 6, 6, 6, 6, originalUnicode, originalGb18030);

   665 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 7, 7, 2, 7, originalUnicode, originalGb18030);

   666 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 8, 10, 0, 8, originalUnicode, originalGb18030);

   668 	INFO_PRINTF1(_L("Testing combined GB18030 characters including 1/2/4 byte"));

   669 	originalGb18030.Set(_L8("A\x95\x32\x82\x36\x32\x81\x40\xC2\xB7\x8E\xEB\x95\x33\x96\x30\x81\x37\x81\x30\xFE\xF1")); //22 bytes

   670 	originalUnicode.Format(_L16("A%c%c%c%c%c%c%c%c%c%c"), 0xD840, 0xDC00, 0x0032, 0x4E02, 0x8DEF, 0x5EAA, 0xD841, 0xDDAE, 0x23EC, 0xE4B8 ); //11 chars (UCS2)

   671 	TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);

   672 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 11, 0, originalGb18030, originalUnicode);

   673 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 4, 10, 1, originalGb18030, originalUnicode);

   674 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 5, 5, 8, 5, originalGb18030, originalUnicode);

   675 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 6, 6, 7, 6, originalGb18030, originalUnicode);

   676 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 8, 9, 6, 8, originalGb18030, originalUnicode);

   677 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 11, 5, 10, originalGb18030, originalUnicode);

   678 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 12, 15, 4, 12, originalGb18030, originalUnicode);

   679 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 16, 19, 2, 16, originalGb18030, originalUnicode);

   680 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 20, 21, 1, 20, originalGb18030, originalUnicode);

   681 	TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 22, 30, 0, 22, originalGb18030, originalUnicode);

   683 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);

   684 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 1), originalGb18030.Mid(0, 1));

   685 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(1, 2), originalGb18030.Mid(1, 4));

   686 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(3, 1), originalGb18030.Mid(5, 1));

   687 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(4, 3), originalGb18030.Mid(6, 6));

   688 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(7, 3), originalGb18030.Mid(12, 8));

   689 	TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(10, 1), originalGb18030.Mid(20, 2));

   691 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 22, 0, originalUnicode, originalGb18030);

   692 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 2, 21, 1, originalUnicode, originalGb18030);

   693 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 17, 3, originalUnicode, originalGb18030);

   695 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 4, 16, 4, originalUnicode, originalGb18030);

   696 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 7, 8, 10, 7, originalUnicode, originalGb18030);

   697 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 9, 9, 6, 9, originalUnicode, originalGb18030);

   698 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 10, 10, 2, 10, originalUnicode, originalGb18030);

   699 	TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 11, 20, 0, 11, originalUnicode, originalGb18030);

   701 	CleanupStack::PopAndDestroy(3); // arrayOfCharacterSetsAvailable and characterSetConverter and fileServerSession

   702 	}

   704 CT_GB18030::CT_GB18030()

   705     {

   706     SetTestStepName(KTestStep_T_GB18030);

   707     }

   709 TVerdict CT_GB18030::doTestStepL()

   710     {

   711     SetTestStepResult(EFail);

   713     __UHEAP_MARK;

   714     TRAPD(error1, DoE32MainL());

   715     __UHEAP_MARKEND;

   717     if(error1 == KErrNone)

   718         {

   719         SetTestStepResult(EPass);

   720         }

   722     return TestStepResult();

   723     }

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--