1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/textandloc/charconvfw/charconvplugins/test/rtest/tsrc/main/t_gb18030.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,723 @@
1.4 +/*
1.5 +* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
1.6 +* All rights reserved.
1.7 +* This component and the accompanying materials are made available
1.8 +* under the terms of "Eclipse Public License v1.0"
1.9 +* which accompanies this distribution, and is available
1.10 +* at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.11 +*
1.12 +* Initial Contributors:
1.13 +* Nokia Corporation - initial contribution.
1.14 +*
1.15 +* Contributors:
1.16 +*
1.17 +* Description:
1.18 +*
1.19 +*/
1.20 +
1.21 +
1.22 +#include <e32std.h>
1.23 +#include <e32base.h>
1.24 +#include <f32file.h>
1.25 +#include <charconv.h>
1.26 +#include "t_gb18030.h"
1.27 +#define test(cond) \
1.28 + { \
1.29 + TBool __bb = (cond); \
1.30 + TEST(__bb); \
1.31 + if (!__bb) \
1.32 + { \
1.33 + ERR_PRINTF1(_L("ERROR: Test Failed")); \
1.34 + User::Leave(1); \
1.35 + } \
1.36 + }
1.37 +
1.38 +const TInt KMibValue = 114;
1.39 +const TInt KBufferLength=100;
1.40 +
1.41 +void CT_GB18030::TestTruncatedConversionFromUnicodeToGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode)
1.42 + {
1.43 + for (TInt i=aOriginalUnicode.Length(); i>=0; --i)
1.44 + {
1.45 + TBuf8<KBufferLength> generatedGb18030;
1.46 + const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedGb18030, aOriginalUnicode.Left(i));
1.47 + test(returnValue>=0);
1.48 + TBuf8<KBufferLength> generatedsecondPartOfGb18030;
1.49 + test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfGb18030, aOriginalUnicode.Mid(i-returnValue))==0);
1.50 + generatedGb18030.Append(generatedsecondPartOfGb18030);
1.51 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.52 + TBuf16<KBufferLength> generatedUnicode;
1.53 + test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedGb18030, state)==0);
1.54 + test(generatedUnicode==aOriginalUnicode);
1.55 + }
1.56 + }
1.57 +
1.58 +void CT_GB18030::TestSplittingConvertingFromUnicodeToGb18030(CCnvCharacterSetConverter& aCharacterSetConverter,
1.59 + TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit,
1.60 + TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfGb18030,
1.61 + const TDesC8& aExpectedGb18030, const TDesC16& aOriginalUnicode)
1.62 + {
1.63 + test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);
1.64 + test(aMaximumLengthUpperLimit<=KBufferLength);
1.65 + TUint8 gb18030Buffer[KBufferLength];
1.66 + for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i)
1.67 + {
1.68 + TPtr8 generatedFirstPartOfGb18030(gb18030Buffer, i);
1.69 + test(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfGb18030, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit);
1.70 + test(generatedFirstPartOfGb18030==aExpectedGb18030.Left(aExpectedLengthOfFirstPartOfGb18030));
1.71 + TBuf8<KBufferLength> generatedSecondPartOfGb18030;
1.72 + test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGb18030, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0);
1.73 + test(generatedSecondPartOfGb18030==aExpectedGb18030.Mid(aExpectedLengthOfFirstPartOfGb18030));
1.74 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.75 + TBuf16<KBufferLength> generatedUnicode;
1.76 + test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfGb18030, state)==0);
1.77 + test(state==CCnvCharacterSetConverter::KStateDefault);
1.78 + TBuf16<KBufferLength> generatedSecondPartOfUnicode;
1.79 + test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfGb18030, state)==0);
1.80 + test(state==CCnvCharacterSetConverter::KStateDefault);
1.81 + generatedUnicode.Append(generatedSecondPartOfUnicode);
1.82 + test(generatedUnicode==aOriginalUnicode);
1.83 + }
1.84 + }
1.85 +
1.86 +void CT_GB18030::TestTruncatedConversionToUnicodeFromGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGb18030)
1.87 + {
1.88 + for (TInt i=aOriginalGb18030.Length(); i>=4; --i) // 4 is the length of GB18030's longest multi-byte characters
1.89 + {
1.90 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.91 + TBuf16<KBufferLength> generatedUnicode;
1.92 + const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalGb18030.Left(i), state);
1.93 + test(returnValue>=0);
1.94 + TBuf16<KBufferLength> generatedsecondPartOfUnicode;
1.95 + test(aCharacterSetConverter.ConvertToUnicode(generatedsecondPartOfUnicode, aOriginalGb18030.Mid(i-returnValue), state)==0);
1.96 + generatedUnicode.Append(generatedsecondPartOfUnicode);
1.97 + test(generatedUnicode==aExpectedUnicode);
1.98 + }
1.99 + }
1.100 +
1.101 +void CT_GB18030::TestSplittingConvertingToUnicodeFromGb18030(CCnvCharacterSetConverter& aCharacterSetConverter,
1.102 +
1.103 + TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit,
1.104 + TInt aExpectedNumberOfGb18030BytesNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfUnicode,
1.105 + const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGb18030)
1.106 + {
1.107 + test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);
1.108 + test(aMaximumLengthUpperLimit<=KBufferLength);
1.109 + TUint16 unicodeBuffer[KBufferLength];
1.110 + for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i)
1.111 + {
1.112 + TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i);
1.113 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.114 + test(aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalGb18030, state)==aExpectedNumberOfGb18030BytesNotConvertedAtSplit);
1.115 + test(generatedFirstPartOfUnicode==aExpectedUnicode.Left(aExpectedLengthOfFirstPartOfUnicode));
1.116 + test(state==CCnvCharacterSetConverter::KStateDefault);
1.117 + TBuf16<KBufferLength> generatedSecondPartOfUnicode;
1.118 + test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalGb18030.Right(aExpectedNumberOfGb18030BytesNotConvertedAtSplit), state)==0);
1.119 + test(generatedSecondPartOfUnicode==aExpectedUnicode.Mid(aExpectedLengthOfFirstPartOfUnicode));
1.120 + test(state==CCnvCharacterSetConverter::KStateDefault);
1.121 + TBuf8<KBufferLength> generatedGb18030;
1.122 + test(aCharacterSetConverter.ConvertFromUnicode(generatedGb18030, generatedFirstPartOfUnicode)==0);
1.123 + TBuf8<KBufferLength> generatedSecondPartOfGb18030;
1.124 + test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGb18030, generatedSecondPartOfUnicode)==0);
1.125 + generatedGb18030.Append(generatedSecondPartOfGb18030);
1.126 + test(generatedGb18030==aOriginalGb18030);
1.127 + }
1.128 + }
1.129 +
1.130 +
1.131 +void CT_GB18030::CharacterSetValueAndMIBTests(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession)
1.132 +{
1.133 + // check that the character set value of '114' is converted to the GB18030 UID (0x10287038)
1.134 + test(aCharacterSetConverter.ConvertMibEnumOfCharacterSetToIdentifierL(KMibValue,aFileServerSession)==KCharacterSetIdentifierGb18030);
1.135 + INFO_PRINTF1(_L("\nMIB->Char Set UID - OK"));
1.136 +
1.137 + // check that the UCS2 GUID (0x10287038) is converted to the character set value of '114'
1.138 + test(aCharacterSetConverter.ConvertCharacterSetIdentifierToMibEnumL(KCharacterSetIdentifierGb18030,aFileServerSession)==KMibValue);
1.139 + INFO_PRINTF1(_L("\nChar Set UID->MIB - OK"));
1.140 +}
1.141 +
1.142 +
1.143 +/**
1.144 +*/
1.145 +void CT_GB18030::TestConversionToUnicodeFromGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGb18030, TInt aExpectedResult)
1.146 + {
1.147 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.148 + TBuf16<KBufferLength> generatedUnicode;
1.149 + const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalGb18030, state);
1.150 + test(returnValue == aExpectedResult );
1.151 + test(generatedUnicode==aExpectedUnicode);
1.152 + }
1.153 +
1.154 +
1.155 +/**
1.156 +*/
1.157 +void CT_GB18030::TestConversionFromUnicodeToGb18030(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode, TInt aExpectedResult)
1.158 + {
1.159 + TBuf8<KBufferLength> generatedGb18030;
1.160 + const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedGb18030, aOriginalUnicode);
1.161 + test(returnValue == aExpectedResult);
1.162 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.163 + TBuf16<KBufferLength> generatedUnicode;
1.164 + test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedGb18030, state)==0);
1.165 + test(generatedUnicode==aOriginalUnicode);
1.166 + }
1.167 +
1.168 +/**
1.169 +@SYMTestCaseID TI18N-CHARCONV-CT-4051
1.170 +@SYMTestCaseDesc Check GB18030 plugin support conversion between one byte GB18030 character and Unicode
1.171 +@SYMTestPriority High
1.172 +@SYMTestActions 1. Select characters from one-byte character set of GB2312-80
1.173 + 2. Pass it to charconv and convert it to Unicode
1.174 + 3. Pass the above Unicode to charconv and convert it to GB18030
1.175 +@SYMTestExpectedResults Conversion is successful, and the returned Unicode/GB18030 is as defined
1.176 +@SYMREQ REQ12065 PREQ12066
1.177 +*/
1.178 +
1.179 +void CT_GB18030::OneByteConversion( CCnvCharacterSetConverter& aCharacterSetConverter )
1.180 +{
1.181 + TPtrC8 originalGb18030;
1.182 + TBuf16<KBufferLength> originalUnicode;
1.183 +
1.184 + // One-byte gb
1.185 + originalGb18030.Set(_L8("\x40"));
1.186 + originalUnicode.Format(_L16("%c"), 0x40);
1.187 +
1.188 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.189 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.190 +
1.191 + // one-byte uincode
1.192 + _LIT16(Uni_0, "\x0000");
1.193 + _LIT8(Gb_0, "\x00");
1.194 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_0);
1.195 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_0, Gb_0);
1.196 +
1.197 + _LIT16(Uni_1, "\x0079");
1.198 + _LIT8(Gb_1, "\x79");
1.199 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_1);
1.200 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_1, Gb_1);
1.201 +
1.202 + _LIT16(Uni_2, "\x0080");
1.203 + _LIT8(Gb_2, "\x81\x30\x81\x30");
1.204 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_2);
1.205 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_2, Gb_2);
1.206 +
1.207 + _LIT16(Uni_3, "\x0081");
1.208 + _LIT8(Gb_3, "\x81\x30\x81\x31");
1.209 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_3);
1.210 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_3, Gb_3);
1.211 +
1.212 + _LIT16(Uni_4, "\x00fe");
1.213 + _LIT8(Gb_4, "\x81\x30\x8B\x36");
1.214 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_4);
1.215 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_4, Gb_4);
1.216 +
1.217 + _LIT16(Uni_5, "\x00ff");
1.218 + _LIT8(Gb_5, "\x81\x30\x8B\x37");
1.219 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_5);
1.220 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_5, Gb_5);
1.221 +}
1.222 +
1.223 +
1.224 +/**
1.225 +@SYMTestCaseID TI18N-CHARCONV-CT-4052
1.226 +@SYMTestCaseDesc Check GB18030 plug-in support conversion between two-byte GB18030 character and Unicode
1.227 +@SYMTestPriority High
1.228 +@SYMTestActions 1. Select characters from two-byte character set from GB2312-80
1.229 + 2. Pass it to charconv and convert it to Unicode
1.230 + 3. Pass the above Unicode to charconv and convert it to GB18030
1.231 + 4. Select characters from two-byte characters set from GBK, outside of GB2312-80, same with GBK
1.232 + 5. Pass to charconv and convert to Unicode
1.233 + 6. Pass the above Unicode to charconv, and conver it to GB18030
1.234 + 7. Select characters from two-byte characters set from GBK, outside of GB2312-80, different from GBK
1.235 + 8. Pass to charconv and convert to Unicode
1.236 + 9. Pass the above Unicode to charconv, and conver it to GB18030
1.237 +@SYMTestExpectedResults Conversion is successful, and the returned Unicode/GB18030 is as defined
1.238 +@SYMREQ REQ12065 REQ12066
1.239 +*/
1.240 +
1.241 +void CT_GB18030::TwoByteConversion( CCnvCharacterSetConverter& aCharacterSetConverter )
1.242 +{
1.243 + TPtrC8 originalGb18030;
1.244 + TBuf16<KBufferLength> originalUnicode;
1.245 +
1.246 + // two-byte gb
1.247 + originalGb18030.Set(_L8("\xec\xe1"));
1.248 + originalUnicode.Format(_L16("%c"), 0x706c);
1.249 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.250 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.251 +
1.252 + originalGb18030.Set(_L8("\x81\x81"));
1.253 + originalUnicode.Format(_L16("%c"), 0x4e96);
1.254 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.255 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.256 +
1.257 + originalGb18030.Set(_L8("\xa2\xe3"));
1.258 + originalUnicode.Format(_L16("%c"), 0x20ac);
1.259 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.260 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.261 + originalGb18030.Set(_L8("\xa6\xd9"));
1.262 + originalUnicode.Format(_L16("%c"), 0xe78d);
1.263 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.264 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.265 + originalGb18030.Set(_L8("\xa8\xbc"));
1.266 + originalUnicode.Format(_L16("%c"), 0x1e3f);
1.267 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.268 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.269 +
1.270 +
1.271 + // two-byte unicode
1.272 + _LIT16(Uni_6, "\x0100");
1.273 + _LIT8(Gb_6, "\x81\x30\x8B\x38");
1.274 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_6);
1.275 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_6, Gb_6);
1.276 +
1.277 + _LIT16(Uni_7, "\x0101");
1.278 + _LIT8(Gb_7, "\xA8\xA1");
1.279 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_7);
1.280 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_7, Gb_7);
1.281 +
1.282 + _LIT16(Uni_8, "\x0ffe");
1.283 + _LIT8(Gb_8, "\x81\x33\x83\x38");
1.284 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_8);
1.285 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_8, Gb_8);
1.286 +
1.287 + _LIT16(Uni_9, "\x0fff");
1.288 + _LIT8(Gb_9, "\x81\x33\x83\x39");
1.289 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_9);
1.290 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_9, Gb_9);
1.291 +
1.292 + _LIT16(Uni_10, "\x1000");
1.293 + _LIT8(Gb_10, "\x81\x33\x84\x30");
1.294 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_10);
1.295 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_10, Gb_10);
1.296 +
1.297 + _LIT16(Uni_11, "\x1001");
1.298 + _LIT8(Gb_11, "\x81\x33\x84\x31");
1.299 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_11);
1.300 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_11, Gb_11);
1.301 +
1.302 + _LIT16(Uni_12, "\xfffe");
1.303 + _LIT8(Gb_12, "\x84\x31\xA4\x38");
1.304 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_12);
1.305 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_12, Gb_12);
1.306 +
1.307 + _LIT16(Uni_13, "\xffff");
1.308 + _LIT8(Gb_13, "\x84\x31\xA4\x39");
1.309 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_13);
1.310 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_13, Gb_13);
1.311 +}
1.312 +
1.313 +/**
1.314 +@SYMTestCaseID TI18N-CHARCONV-CT-4056
1.315 +@SYMTestCaseDesc Check GB18030 plug-in support conversion between four-byte GB18030 character and Unicode
1.316 +@SYMTestPriority High
1.317 +@SYMTestActions 1. Select characters from CJK A
1.318 + 2. Pass it to charconv and convert it to Unicode
1.319 + 3. Pass the above Unicode to charconv and convert it to GB18030
1.320 + 4. Select characters from CJK B
1.321 + 5. Pass it to charconv and convert it to Unicode
1.322 + 6. Pass the above Unicode to charconv and convert it to GB18030
1.323 +@SYMTestExpectedResults Conversion is successful, and the returned Unicode/GB18030 is as defined
1.324 +@SYMREQ REQ12065 REQ12066
1.325 +*/
1.326 +
1.327 +void CT_GB18030::FourByteConversion( CCnvCharacterSetConverter& aCharacterSetConverter )
1.328 +{
1.329 + TPtrC8 originalGb18030;
1.330 + TBuf16<KBufferLength> originalUnicode;
1.331 +
1.332 + // four-byte gb
1.333 + originalGb18030.Set(_L8("\x82\x30\xA7\x30"));
1.334 + originalUnicode.Format(_L16("%c"), 0x3622);
1.335 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.336 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.337 +
1.338 + originalGb18030.Set(_L8("\x95\x32\xad\x35"));
1.339 + originalUnicode.Format(_L16("%c%c"), 0xd840, 0xddad );//0x201ad)
1.340 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.341 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.342 +
1.343 + // four-byte unicode
1.344 + _LIT16(Uni_14, "\xd840\xdc00");
1.345 + _LIT8(gb_14, "\x95\x32\x82\x36");
1.346 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_14);
1.347 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_14, gb_14);
1.348 +
1.349 + _LIT16(Uni_15, "\xd840\xdc01");
1.350 + _LIT8(gb_15, "\x95\x32\x82\x37");
1.351 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_15);
1.352 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_15, gb_15);
1.353 +
1.354 + _LIT16(Uni_16, "\xD87F\xdffe");
1.355 + _LIT8(gb_16, "\x9a\x34\x84\x30");
1.356 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_16);
1.357 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_16, gb_16);
1.358 +
1.359 + _LIT16(Uni_17, "\xD87F\xdfff");
1.360 + _LIT8(gb_17, "\x9a\x34\x84\x31");
1.361 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, Uni_17);
1.362 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, Uni_17, gb_17);
1.363 +}
1.364 +
1.365 +
1.366 +/**
1.367 +@SYMTestCaseID TI18N-CHARCONV-CT-4054
1.368 +@SYMTestCaseDesc Check GB18030 plug-in support conversion between one-byte GB18030 character and Unicode, negative input
1.369 +@SYMTestPriority High
1.370 +@SYMTestActions 1. Select one-byte characters which are not mapped to Unicode
1.371 + 2. Pass it to charconv and convert it to Unicode
1.372 + 3. Select one-byte code point which is not valid in GB18030
1.373 + 4. Pass it to charconv and convert it to Unicode
1.374 +@SYMTestExpectedResults No side effect
1.375 +@SYMREQ REQ12065 REQ12066
1.376 +*/
1.377 +
1.378 +void CT_GB18030::OneByteConversionNegative( CCnvCharacterSetConverter& aCharacterSetConverter )
1.379 +{
1.380 + TPtrC8 originalGb18030;
1.381 + TBuf16<KBufferLength> originalUnicode;
1.382 +
1.383 + originalGb18030.Set(_L8("\x0e"));
1.384 + originalUnicode.Format(_L16("%c"), 0x0e);
1.385 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.386 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030);
1.387 +
1.388 + originalGb18030.Set(_L8("\xa0"));
1.389 + originalUnicode.Copy( _L("") );
1.390 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.391 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030, CCnvCharacterSetConverter::EErrorIllFormedInput );
1.392 +}
1.393 +
1.394 +
1.395 +/**
1.396 +@SYMTestCaseID TI18N-CHARCONV-CT-4055
1.397 +@SYMTestCaseDesc Check GB18030 plug-in support conversion between two-byte GB18030 character and Unicode, negative input
1.398 +@SYMTestPriority High
1.399 +@SYMTestActions 1. Select two-byte characters which are not mapped to Unicode
1.400 + 2. Pass it to charconv and convert it to Unicode
1.401 + 3. Select two-byte code points which are not valid in GB18030
1.402 + 4. Pass it to charconv and convert it to Unicode
1.403 +@SYMTestExpectedResults No side effect
1.404 +@SYMREQ REQ12065 REQ12066
1.405 +*/
1.406 +
1.407 +void CT_GB18030::TwoByteConversionNegative( CCnvCharacterSetConverter& aCharacterSetConverter )
1.408 +{
1.409 + TPtrC8 originalGb18030;
1.410 + TBuf16<KBufferLength> originalUnicode;
1.411 +
1.412 + originalGb18030.Set(_L8("\xa0\x7f"));
1.413 + originalUnicode.Copy( _L("") );
1.414 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.415 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030, CCnvCharacterSetConverter::EErrorIllFormedInput );
1.416 +}
1.417 +
1.418 +
1.419 +/**
1.420 +@SYMTestCaseID TI18N-CHARCONV-CT-4056
1.421 +@SYMTestCaseDesc Check GB18030 plug-in support conversion between four-byte GB18030 character and Unicode, negative input
1.422 +@SYMTestPriority High
1.423 +@SYMTestActions 1. Select four-byte characters which are not mapped to Unicode
1.424 + 2. Pass it to charconv and convert it to Unicode
1.425 + 3. Select four-byte code points which are not valid in GB18030
1.426 + 4. Pass it to charconv and convert it to Unicode
1.427 +@SYMTestExpectedResults No side effect
1.428 +@SYMREQ REQ12065 REQ12066
1.429 +*/
1.430 +
1.431 +void CT_GB18030::FourByteConversionNegative( CCnvCharacterSetConverter& aCharacterSetConverter )
1.432 +{
1.433 + TPtrC8 originalGb18030;
1.434 + TBuf16<KBufferLength> originalUnicode;
1.435 +
1.436 + originalGb18030.Set(_L8("\x81\x30\x81\x3a"));
1.437 + originalUnicode.Copy( _L("") );
1.438 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.439 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030, CCnvCharacterSetConverter::EErrorIllFormedInput );
1.440 +}
1.441 +
1.442 +
1.443 +/**
1.444 +@SYMTestCaseID TI18N-CHARCONV-CT-4053
1.445 +@SYMTestCaseDesc Check GB18030 plug-in support conversion between problematic GB18030 character and Unicode, negative input
1.446 +@SYMTestPriority High
1.447 +@SYMTestActions 1. Select characters whose trailing byte is in the range of leading bytes
1.448 + 2. Pass it to charconv and convert it to Unicode
1.449 + 3. Select Unicode whose leading/trailing byte is in the range of low-ANSI
1.450 + 4. Pass it to charconv and convert it to GB18030
1.451 + 5. Select characters whose trailing byte is special symbol like backslash
1.452 + 6. Pass it to charconv and convert it to Unicode
1.453 +@SYMTestExpectedResults No side effect
1.454 +@SYMREQ REQ12065 REQ12066
1.455 +*/
1.456 +
1.457 +void CT_GB18030::ProblemProneCharcters( CCnvCharacterSetConverter& aCharacterSetConverter )
1.458 +{
1.459 + TPtrC8 originalGb18030;
1.460 + TBuf16<KBufferLength> originalUnicode;
1.461 +
1.462 + originalGb18030.Set(_L8("\x81\x81\xba\xba\xa0\xa0\xf7\xf7"));
1.463 + originalUnicode.Format(_L16("%c%c%c%c"), 0x4e96, 0x6c49, 0x724b, 0x9f22);
1.464 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.465 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );
1.466 +
1.467 + originalGb18030.Set(_L8("\xc4\x40\x83\xa0\xa0\x7c\xa0\x86"));
1.468 + originalUnicode.Format(_L16("%c%c%c%c"), 0x8140, 0x512c, 0x7218, 0x7222);
1.469 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.470 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );
1.471 +
1.472 + originalGb18030.Set(_L8("\x81\x43\x81\x63\xf7\x4d\xf7\x6d\xa0\x53\xa0\x73"));
1.473 + originalUnicode.Format(_L16("%c%c%c%c%c%c"), 0x4E06, 0x4E67, 0x9C49, 0x9C69, 0x71EC, 0x720F);
1.474 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.475 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );
1.476 +
1.477 + 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"));
1.478 + 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);
1.479 + TestConversionFromUnicodeToGb18030(aCharacterSetConverter, originalUnicode);
1.480 + TestConversionToUnicodeFromGb18030(aCharacterSetConverter, originalUnicode, originalGb18030 );
1.481 +}
1.482 +
1.483 +
1.484 +void CT_GB18030::DoE32MainL()
1.485 + {
1.486 + RFs fileServerSession;
1.487 + CleanupClosePushL(fileServerSession);
1.488 + User::LeaveIfError(fileServerSession.Connect());
1.489 + CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC();
1.490 + CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(fileServerSession);
1.491 + INFO_PRINTF1(_L("Available:\n"));
1.492 + for (TInt i=arrayOfCharacterSetsAvailable->Count()-1; i>=0; --i)
1.493 + {
1.494 + const CCnvCharacterSetConverter::SCharacterSet& charactersSet=(*arrayOfCharacterSetsAvailable)[i];
1.495 + characterSetConverter->PrepareToConvertToOrFromL(charactersSet.Identifier(), *arrayOfCharacterSetsAvailable, fileServerSession);
1.496 + TPtrC charactersSetName(charactersSet.Name());
1.497 + if (charactersSet.NameIsFileName())
1.498 + {
1.499 + charactersSetName.Set(TParsePtrC(charactersSetName).Name());
1.500 + }
1.501 + INFO_PRINTF2(_L(" %S\n"), &charactersSetName);
1.502 + }
1.503 + TPtrC8 originalGb18030;
1.504 + TBuf16<KBufferLength> originalUnicode;
1.505 + TBuf8<KBufferLength> generatedGb18030;
1.506 + TBuf16<KBufferLength> generatedUnicode;
1.507 + TInt state=CCnvCharacterSetConverter::KStateDefault;
1.508 +
1.509 + // test that we can get MIB and Charset values
1.510 + CharacterSetValueAndMIBTests(*characterSetConverter, fileServerSession);
1.511 +
1.512 + characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierGb18030, *arrayOfCharacterSetsAvailable, fileServerSession);
1.513 +
1.514 + INFO_PRINTF1( _L("GB18030 one byte support") );
1.515 + OneByteConversion( *characterSetConverter );
1.516 +
1.517 + INFO_PRINTF1( _L("GB18030 two byte support") );
1.518 + TwoByteConversion( *characterSetConverter );
1.519 +
1.520 + INFO_PRINTF1( _L("GB18030 four byte support") );
1.521 + FourByteConversion( *characterSetConverter );
1.522 +
1.523 + INFO_PRINTF1( _L("GB18030 one byte support with negative input") );
1.524 + OneByteConversionNegative( *characterSetConverter );
1.525 +
1.526 + INFO_PRINTF1( _L("GB18030 two byte support with negative input") );
1.527 + TwoByteConversionNegative( *characterSetConverter );
1.528 +
1.529 + INFO_PRINTF1( _L("GB18030 four byte support with negative input") );
1.530 + FourByteConversionNegative( *characterSetConverter );
1.531 +
1.532 + INFO_PRINTF1( _L("Problem prone characters") );
1.533 + ProblemProneCharcters( *characterSetConverter );
1.534 +
1.535 + INFO_PRINTF1(_L("Testing characters shared with GB 2312-80 and characters only in GBK"));
1.536 +
1.537 + 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
1.538 + originalUnicode.Format(_L16("A%c%c%c%c%cE b%c%c%c"), 0x9f77, 0x837b, 0x9119, 0x95b9, 0x94e6, 0x89bb, 0x8938, 0x66b2);
1.539 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.540 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 12, 0, originalGb18030, originalUnicode);
1.541 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 2, 11, 1, originalGb18030, originalUnicode);
1.542 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 3, 4, 10, 3, originalGb18030, originalUnicode);
1.543 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 5, 6, 9, 5, originalGb18030, originalUnicode);
1.544 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 7, 8, 8, 7, originalGb18030, originalUnicode);
1.545 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 9, 10, 7, 9, originalGb18030, originalUnicode);
1.546 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 11, 11, 6, 11, originalGb18030, originalUnicode);
1.547 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 12, 12, 5, 12, originalGb18030, originalUnicode);
1.548 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 13, 13, 4, 13, originalGb18030, originalUnicode);
1.549 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 14, 15, 3, 14, originalGb18030, originalUnicode);
1.550 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 16, 17, 2, 16, originalGb18030, originalUnicode);
1.551 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 18, 19, 1, 18, originalGb18030, originalUnicode);
1.552 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 20, 40, 0, 20, originalGb18030, originalUnicode);
1.553 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.554 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(1, 2), originalGb18030.Mid(1, 4));
1.555 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 20, 0, originalUnicode, originalGb18030);
1.556 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 19, 1, originalUnicode, originalGb18030);
1.557 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 17, 2, originalUnicode, originalGb18030);
1.558 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 15, 3, originalUnicode, originalGb18030);
1.559 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 4, 13, 4, originalUnicode, originalGb18030);
1.560 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 5, 5, 11, 5, originalUnicode, originalGb18030);
1.561 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 6, 6, 9, 6, originalUnicode, originalGb18030);
1.562 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 7, 7, 8, 7, originalUnicode, originalGb18030);
1.563 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 8, 8, 7, 8, originalUnicode, originalGb18030);
1.564 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 9, 9, 6, 9, originalUnicode, originalGb18030);
1.565 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 10, 10, 4, 10, originalUnicode, originalGb18030);
1.566 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 11, 11, 2, 11, originalUnicode, originalGb18030);
1.567 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 12, 30, 0, 12, originalUnicode, originalGb18030);
1.568 +
1.569 + INFO_PRINTF1(_L("Testing GB18030 characters where the first byte has the high-bit set and the second byte doesn't"));
1.570 + originalGb18030.Set(_L8("\x20\x5d\xa0\x5d\xa0\xdd"));
1.571 + originalUnicode.Format(_L16(" ]%c%c"), 0x71f7, 0x72a6);
1.572 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.573 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 4, 0, originalGb18030, originalUnicode);
1.574 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 1, 3, 1, originalGb18030, originalUnicode);
1.575 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 2, 2, originalGb18030, originalUnicode);
1.576 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 1, 4, originalGb18030, originalUnicode);
1.577 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 6, 20, 0, 6, originalGb18030, originalUnicode);
1.578 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.579 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 6, 0, originalUnicode, originalGb18030);
1.580 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 5, 1, originalUnicode, originalGb18030);
1.581 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 4, 2, originalUnicode, originalGb18030);
1.582 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 2, 3, originalUnicode, originalGb18030);
1.583 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 20, 0, 4, originalUnicode, originalGb18030);
1.584 +
1.585 + INFO_PRINTF1(_L("Testing truncated GB18030 sequences"));
1.586 + originalGb18030.Set(_L8("qwe\xb5"));
1.587 + test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGb18030, state)==1);
1.588 + test(state==CCnvCharacterSetConverter::KStateDefault);
1.589 + test(generatedUnicode==_L16("qwe"));
1.590 +
1.591 + originalGb18030.Set(_L8("qwe\x81\x30"));
1.592 + test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGb18030, state)==2);
1.593 + test(state==CCnvCharacterSetConverter::KStateDefault);
1.594 + test(generatedUnicode==_L16("qwe"));
1.595 +
1.596 + INFO_PRINTF1(_L("Testing 4 byte characters, including surrogate pair"));
1.597 + originalGb18030.Set(_L8("C\x81\x30\x81\x30\x82\x30\x81\x30\x95\x32\x82\x36")); // 13 byte
1.598 + originalUnicode.Format(_L16("C%c%c%c%c"), 0x0080, 0x34A3, 0xD840, 0xDC00); // 4 Char (3 UCS2, 1 surrogate pair)
1.599 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.600 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 5, 0, originalGb18030, originalUnicode);
1.601 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 4, 4, 1, originalGb18030, originalUnicode);
1.602 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 5, 8, 3, 5, originalGb18030, originalUnicode);
1.603 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 9, 12, 2, 9, originalGb18030, originalUnicode);
1.604 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 13, 40, 0, 13, originalGb18030, originalUnicode);
1.605 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.606 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(1, 2), originalGb18030.Mid(1, 8));
1.607 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(3, 2), originalGb18030.Mid(9, 4));
1.608 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 13, 0, originalUnicode, originalGb18030);
1.609 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 12, 1, originalUnicode, originalGb18030);
1.610 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 8, 2, originalUnicode, originalGb18030);
1.611 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 4, 4, 3, originalUnicode, originalGb18030);
1.612 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 5, 30, 0, 5, originalUnicode, originalGb18030);
1.613 +
1.614 + INFO_PRINTF1(_L("Testing GB18030 characters which have different mapping with GB2312-80"));
1.615 + originalGb18030.Set(_L8("\xa1\xaa\xa1\xa4\xa8\x44\x81\x39\xa7\x39")); // 10 byte
1.616 + originalUnicode.Format(_L16("%c%c%c%c"), 0x2014, 0x00B7, 0x2015, 0x30FB); // 4 char (UCS2)
1.617 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.618 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 1, 4, 0, originalGb18030, originalUnicode);
1.619 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 3, 2, originalGb18030, originalUnicode);
1.620 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 2, 4, originalGb18030, originalUnicode);
1.621 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 6, 9, 1, 6, originalGb18030, originalUnicode);
1.622 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 20, 0, 10, originalGb18030, originalUnicode);
1.623 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.624 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 2), originalGb18030.Mid(0, 4));
1.625 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(2, 2), originalGb18030.Mid(4, 6));
1.626 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 10, 0, originalUnicode, originalGb18030);
1.627 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 8, 1, originalUnicode, originalGb18030);
1.628 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 6, 2, originalUnicode, originalGb18030);
1.629 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 4, 3, originalUnicode, originalGb18030);
1.630 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 10, 0, 4, originalUnicode, originalGb18030);
1.631 +
1.632 + INFO_PRINTF1(_L("Testing 2 byte GB18030 characters which have different mapping with GBK"));
1.633 + originalGb18030.Set(_L8("\xa1\xa4\xa1\xaa\xa8\xbc\xa8\xbf\xa9\x8a")); // 10 byte
1.634 + originalUnicode.Format(_L16("%c%c%c%c%c"), 0x00b7, 0x2014, 0x1e3f, 0x01f9, 0x2ff0); // 5 char (UCS2)
1.635 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.636 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 1, 5, 0, originalGb18030, originalUnicode);
1.637 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 4, 2, originalGb18030, originalUnicode);
1.638 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 3, 4, originalGb18030, originalUnicode);
1.639 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 20, 0, 10, originalGb18030, originalUnicode);
1.640 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.641 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 2), originalGb18030.Mid(0, 4));
1.642 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(2, 3), originalGb18030.Mid(4, 6));
1.643 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 10, 0, originalUnicode, originalGb18030);
1.644 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 8, 1, originalUnicode, originalGb18030);
1.645 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 6, 2, originalUnicode, originalGb18030);
1.646 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 5, 10, 0, 5, originalUnicode, originalGb18030);
1.647 +
1.648 + INFO_PRINTF1(_L("Testing 2/4 byte GB18030 characters mapping to PUA codes"));
1.649 + 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
1.650 + originalUnicode.Format(_L16("%c%c%c%c%c%c%c%c"), 0xE4C5, 0xE49B, 0xE451, 0xE7BB, 0xFF4B, 0xFFFF, 0xE9AC, 0xFF11); // 8 char (UCS2)
1.651 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.652 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 1, 8, 0, originalGb18030, originalUnicode);
1.653 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 2, 3, 7, 2, originalGb18030, originalUnicode);
1.654 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 4, 5, 6, 4, originalGb18030, originalUnicode);
1.655 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 13, 3, 10, originalGb18030, originalUnicode);
1.656 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 14, 17, 2, 14, originalGb18030, originalUnicode);
1.657 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 18, 19, 1, 18, originalGb18030, originalUnicode);
1.658 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 20, 40, 0, 20, originalGb18030, originalUnicode);
1.659 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.660 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 2), originalGb18030.Mid(0, 4));
1.661 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(2, 3), originalGb18030.Mid(4, 6));
1.662 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(5, 2), originalGb18030.Mid(10, 8));
1.663 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(7, 1), originalGb18030.Mid(18, 2));
1.664 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 20, 0, originalUnicode, originalGb18030);
1.665 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 1, 18, 1, originalUnicode, originalGb18030);
1.666 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 2, 2, 16, 2, originalUnicode, originalGb18030);
1.667 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 6, 6, 6, 6, originalUnicode, originalGb18030);
1.668 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 7, 7, 2, 7, originalUnicode, originalGb18030);
1.669 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 8, 10, 0, 8, originalUnicode, originalGb18030);
1.670 +
1.671 + INFO_PRINTF1(_L("Testing combined GB18030 characters including 1/2/4 byte"));
1.672 + 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
1.673 + 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)
1.674 + TestTruncatedConversionFromUnicodeToGb18030(*characterSetConverter, originalUnicode);
1.675 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 0, 0, 11, 0, originalGb18030, originalUnicode);
1.676 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 1, 4, 10, 1, originalGb18030, originalUnicode);
1.677 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 5, 5, 8, 5, originalGb18030, originalUnicode);
1.678 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 6, 6, 7, 6, originalGb18030, originalUnicode);
1.679 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 8, 9, 6, 8, originalGb18030, originalUnicode);
1.680 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 10, 11, 5, 10, originalGb18030, originalUnicode);
1.681 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 12, 15, 4, 12, originalGb18030, originalUnicode);
1.682 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 16, 19, 2, 16, originalGb18030, originalUnicode);
1.683 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 20, 21, 1, 20, originalGb18030, originalUnicode);
1.684 + TestSplittingConvertingFromUnicodeToGb18030(*characterSetConverter, 22, 30, 0, 22, originalGb18030, originalUnicode);
1.685 +
1.686 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode, originalGb18030);
1.687 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(0, 1), originalGb18030.Mid(0, 1));
1.688 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(1, 2), originalGb18030.Mid(1, 4));
1.689 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(3, 1), originalGb18030.Mid(5, 1));
1.690 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(4, 3), originalGb18030.Mid(6, 6));
1.691 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(7, 3), originalGb18030.Mid(12, 8));
1.692 + TestTruncatedConversionToUnicodeFromGb18030(*characterSetConverter, originalUnicode.Mid(10, 1), originalGb18030.Mid(20, 2));
1.693 +
1.694 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 0, 0, 22, 0, originalUnicode, originalGb18030);
1.695 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 1, 2, 21, 1, originalUnicode, originalGb18030);
1.696 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 3, 3, 17, 3, originalUnicode, originalGb18030);
1.697 +
1.698 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 4, 4, 16, 4, originalUnicode, originalGb18030);
1.699 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 7, 8, 10, 7, originalUnicode, originalGb18030);
1.700 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 9, 9, 6, 9, originalUnicode, originalGb18030);
1.701 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 10, 10, 2, 10, originalUnicode, originalGb18030);
1.702 + TestSplittingConvertingToUnicodeFromGb18030(*characterSetConverter, 11, 20, 0, 11, originalUnicode, originalGb18030);
1.703 +
1.704 + CleanupStack::PopAndDestroy(3); // arrayOfCharacterSetsAvailable and characterSetConverter and fileServerSession
1.705 + }
1.706 +
1.707 +CT_GB18030::CT_GB18030()
1.708 + {
1.709 + SetTestStepName(KTestStep_T_GB18030);
1.710 + }
1.711 +
1.712 +TVerdict CT_GB18030::doTestStepL()
1.713 + {
1.714 + SetTestStepResult(EFail);
1.715 +
1.716 + __UHEAP_MARK;
1.717 + TRAPD(error1, DoE32MainL());
1.718 + __UHEAP_MARKEND;
1.719 +
1.720 + if(error1 == KErrNone)
1.721 + {
1.722 + SetTestStepResult(EPass);
1.723 + }
1.724 +
1.725 + return TestStepResult();
1.726 + }