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

     1 /*

     2 * Copyright (c) 1997-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_gbk.h"

    25 #define test(cond)                                  \

    26     {                                               \

    27     TBool __bb = (cond);                            \

    28     TEST(__bb);                                     \

    29     if (!__bb)                                      \

    30         {                                           \

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

    32         User::Leave(1);                             \

    33         }                                           \

    34     }

    36 const TInt KMibValue = 113;

    37 const TInt KBufferLength=100;

    38 /**

    39 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0509

    40 @SYMTestCaseDesc        Tests for truncated conversion from Unicode to GBK

    41 @SYMTestPriority        Medium

    42 @SYMTestActions         Tests for truncated conversion from Unicode to Gbk and back to Unicode.

    43                         Tests for the generated Unicode with original Unicode

    44 @SYMTestExpectedResults Test must not fail

    45 @SYMREQ                 REQ0000

    46 */

    47 void CT_GBK::TestTruncatedConversionFromUnicodeToGbk(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode)

    48 	{

    49 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0509 "));

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

    51 		{

    52 		TBuf8<KBufferLength> generatedGbk;

    53 		const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedGbk, aOriginalUnicode.Left(i));

    54 		test(returnValue>=0);

    55 		TBuf8<KBufferLength> generatedsecondPartOfGbk;

    56 		test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfGbk, aOriginalUnicode.Mid(i-returnValue))==0);

    57 		generatedGbk.Append(generatedsecondPartOfGbk);

    58 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    59 		TBuf16<KBufferLength> generatedUnicode;

    60 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedGbk, state)==0);

    61 		test(generatedUnicode==aOriginalUnicode);

    62 		}

    63 	}

    64 /**

    65 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0510

    66 @SYMTestCaseDesc        Splitting and converting from Unicode to GBK test

    67 @SYMTestPriority        Medium

    68 @SYMTestActions         Tests for conversion after splitting from Unicode to Gbk and back to Unicode

    69 						Tests for the generated Unicode with original Unicode

    70 @SYMTestExpectedResults Test must not fail

    71 @SYMREQ                 REQ0000

    72 */

    73 void CT_GBK::TestSplittingConvertingFromUnicodeToGbk(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfGbk, const TDesC8& aExpectedGbk, const TDesC16& aOriginalUnicode)

    74 	{

    75 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0510 "));

    76 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

    77 	test(aMaximumLengthUpperLimit<=KBufferLength);

    78 	TUint8 gbkBuffer[KBufferLength];

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

    80 		{

    81 		TPtr8 generatedFirstPartOfGbk(gbkBuffer, i);

    82 		test(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfGbk, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit);

    83 		test(generatedFirstPartOfGbk==aExpectedGbk.Left(aExpectedLengthOfFirstPartOfGbk));

    84 		TBuf8<KBufferLength> generatedSecondPartOfGbk;

    85 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGbk, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0);

    86 		test(generatedSecondPartOfGbk==aExpectedGbk.Mid(aExpectedLengthOfFirstPartOfGbk));

    87 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    88 		TBuf16<KBufferLength> generatedUnicode;

    89 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfGbk, state)==0);

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

    91 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

    92 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfGbk, state)==0);

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

    94 		generatedUnicode.Append(generatedSecondPartOfUnicode);

    95 		test(generatedUnicode==aOriginalUnicode);

    96 		}

    97 	}

    98 /**

    99 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0511

   100 @SYMTestCaseDesc        Tests for truncated conversion from GBK to Unicode

   101 @SYMTestPriority        Medium

   102 @SYMTestActions         Tests for conversion after truncation from Unicode to Hz and back to Unicode

   103 @SYMTestExpectedResults Test must not fail

   104 @SYMREQ                 REQ0000

   105 */

   106 void CT_GBK::TestTruncatedConversionToUnicodeFromGbk(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGbk)

   107 	{

   108 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0511 "));

   109 	for (TInt i=aOriginalGbk.Length(); i>=2; --i) // 2 is the length of GBK's longest multi-byte characters

   110 		{

   111 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   112 		TBuf16<KBufferLength> generatedUnicode;

   113 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalGbk.Left(i), state);

   114 		test(returnValue>=0);

   115 		TBuf16<KBufferLength> generatedsecondPartOfUnicode;

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

   117 		generatedUnicode.Append(generatedsecondPartOfUnicode);

   118 		test(generatedUnicode==aExpectedUnicode);

   119 		}

   120 	}

   121 /**

   122 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0512

   123 @SYMTestCaseDesc        Splitting and converting from GBK to Unicode test

   124 @SYMTestPriority        Medium

   125 @SYMTestActions         Tests for conversion after splitting from Hz to Unicode and back to Hz

   126 @SYMTestExpectedResults Test must not fail

   127 @SYMREQ                 REQ0000

   128 */

   129 void CT_GBK::TestSplittingConvertingToUnicodeFromGbk(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfGbkBytesNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfUnicode, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalGbk)

   130 	{

   131 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0512 "));

   132 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

   133 	test(aMaximumLengthUpperLimit<=KBufferLength);

   134 	TUint16 unicodeBuffer[KBufferLength];

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

   136 		{

   137 		TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i);

   138 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   139 		test(aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalGbk, state)==aExpectedNumberOfGbkBytesNotConvertedAtSplit);

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

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

   142 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

   143 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalGbk.Right(aExpectedNumberOfGbkBytesNotConvertedAtSplit), state)==0);

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

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

   146 		TBuf8<KBufferLength> generatedGbk;

   147 		test(aCharacterSetConverter.ConvertFromUnicode(generatedGbk, generatedFirstPartOfUnicode)==0);

   148 		TBuf8<KBufferLength> generatedSecondPartOfGbk;

   149 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfGbk, generatedSecondPartOfUnicode)==0);

   150 		generatedGbk.Append(generatedSecondPartOfGbk);

   151 		test(generatedGbk==aOriginalGbk);

   152 		}

   153 	}

   156 /**

   157 Tests retreiving the MIB value from the GBK UID

   158 Tests retreiving the GBK UID from the MIB value

   160 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0513

   161 @SYMTestCaseDesc        Tests for conversion from MIB to UID and UID to MIB

   162 @SYMTestPriority        Medium

   163 @SYMTestActions         Tests CCnvCharacterSetConverter::ConvertMibEnumOfCharacterSetToIdentifierL(),

   164                         CCnvCharacterSetConverter::ConvertCharacterSetIdentifierToMibEnumL() functions

   165 @SYMTestExpectedResults Test must not fail

   166 @SYMREQ                 REQ0000

   167 */

   168 void CT_GBK::CharacterSetValueAndMIBTests(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession)

   169 {

   170 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0513 "));

   171 	// check that the character set value of '113' is converted to the GBK UID (0x10003ecb)

   172 	test(aCharacterSetConverter.ConvertMibEnumOfCharacterSetToIdentifierL(KMibValue,aFileServerSession)==KCharacterSetIdentifierGbk);

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

   175 	// check that the UCS2 GUID (0x10003ecb) is converted to the character set value of '113'

   176 	test(aCharacterSetConverter.ConvertCharacterSetIdentifierToMibEnumL(KCharacterSetIdentifierGbk,aFileServerSession)==KMibValue);

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

   178 }

   179 /**

   180 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0514

   181 @SYMTestCaseDesc        Conversion tests for GBK to Unicode

   182 @SYMTestPriority        Medium

   183 @SYMTestActions         Tests for conversion from GBK to Unicode and vice versa.

   184 @SYMTestExpectedResults Test must not fail

   185 @SYMREQ                 REQ0000

   186 */

   187 void CT_GBK::DoE32MainL()

   188 	{

   189 	RFs fileServerSession;

   190 	CleanupClosePushL(fileServerSession);

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

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

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

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

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

   196 		{

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

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

   199 		TPtrC charactersSetName(charactersSet.Name());

   200 		if (charactersSet.NameIsFileName())

   201 			{

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

   203 			}

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

   205 		}

   206 	TPtrC8 originalGbk;

   207 	TBuf16<KBufferLength> originalUnicode;

   208 	TBuf8<KBufferLength> generatedGbk;

   209 	TBuf16<KBufferLength> generatedUnicode;

   210 	TInt state=CCnvCharacterSetConverter::KStateDefault;

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

   213 	CharacterSetValueAndMIBTests(*characterSetConverter, fileServerSession);

   215 	characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierGbk, *arrayOfCharacterSetsAvailable, fileServerSession);

   217 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0514 Testing characters shared with GB 2312-80 and characters only in GBK "));

   218 	originalGbk.Set(_L8("A\xfd\x7d\xdd\xb6\xb1\xc9\xe9\x8e\xe8\x9d""E b\xd3\x59\xd2\x40\x95\xc0"));

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

   220 	TestTruncatedConversionFromUnicodeToGbk(*characterSetConverter, originalUnicode);

   221 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 0, 0, 12, 0, originalGbk, originalUnicode);

   222 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 1, 2, 11, 1, originalGbk, originalUnicode);

   223 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 3, 4, 10, 3, originalGbk, originalUnicode);

   224 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 5, 6, 9, 5, originalGbk, originalUnicode);

   225 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 7, 8, 8, 7, originalGbk, originalUnicode);

   226 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 9, 10, 7, 9, originalGbk, originalUnicode);

   227 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 11, 11, 6, 11, originalGbk, originalUnicode);

   228 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 12, 12, 5, 12, originalGbk, originalUnicode);

   229 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 13, 13, 4, 13, originalGbk, originalUnicode);

   230 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 14, 15, 3, 14, originalGbk, originalUnicode);

   231 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 16, 17, 2, 16, originalGbk, originalUnicode);

   232 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 18, 19, 1, 18, originalGbk, originalUnicode);

   233 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 20, 40, 0, 20, originalGbk, originalUnicode);

   234 	TestTruncatedConversionToUnicodeFromGbk(*characterSetConverter, originalUnicode, originalGbk);

   235 	TestTruncatedConversionToUnicodeFromGbk(*characterSetConverter, originalUnicode.Mid(1, 2), originalGbk.Mid(1, 4));

   236 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 0, 0, 20, 0, originalUnicode, originalGbk);

   237 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 1, 1, 19, 1, originalUnicode, originalGbk);

   238 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 2, 2, 17, 2, originalUnicode, originalGbk);

   239 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 3, 3, 15, 3, originalUnicode, originalGbk);

   240 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 4, 4, 13, 4, originalUnicode, originalGbk);

   241 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 5, 5, 11, 5, originalUnicode, originalGbk);

   242 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 6, 6, 9, 6, originalUnicode, originalGbk);

   243 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 7, 7, 8, 7, originalUnicode, originalGbk);

   244 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 8, 8, 7, 8, originalUnicode, originalGbk);

   245 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 9, 9, 6, 9, originalUnicode, originalGbk);

   246 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 10, 10, 4, 10, originalUnicode, originalGbk);

   247 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 11, 11, 2, 11, originalUnicode, originalGbk);

   248 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 12, 30, 0, 12, originalUnicode, originalGbk);

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

   251 	originalGbk.Set(_L8("\x20\x5d\xa0\x5d\xa0\xdd"));

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

   253 	TestTruncatedConversionFromUnicodeToGbk(*characterSetConverter, originalUnicode);

   254 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 0, 0, 4, 0, originalGbk, originalUnicode);

   255 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 1, 1, 3, 1, originalGbk, originalUnicode);

   256 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 2, 3, 2, 2, originalGbk, originalUnicode);

   257 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 4, 5, 1, 4, originalGbk, originalUnicode);

   258 	TestSplittingConvertingFromUnicodeToGbk(*characterSetConverter, 6, 20, 0, 6, originalGbk, originalUnicode);

   259 	TestTruncatedConversionToUnicodeFromGbk(*characterSetConverter, originalUnicode, originalGbk);

   260 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 0, 0, 6, 0, originalUnicode, originalGbk);

   261 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 1, 1, 5, 1, originalUnicode, originalGbk);

   262 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 2, 2, 4, 2, originalUnicode, originalGbk);

   263 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 3, 3, 2, 3, originalUnicode, originalGbk);

   264 	TestSplittingConvertingToUnicodeFromGbk(*characterSetConverter, 4, 20, 0, 4, originalUnicode, originalGbk);

   266 	INFO_PRINTF1(_L("Testing the many-to-many mapping in GBK"));

   267 	originalGbk.Set(_L8("\xa8\x44\xa1\xaa"));

   268 	test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGbk, state)==0);

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

   270 	test(generatedUnicode.Length()==2);

   271 	test(generatedUnicode[0]==0x2015);

   272 	test(generatedUnicode[1]==0x2015);

   273 	originalUnicode.SetLength(2);

   274 	originalUnicode[0]=0x2014;

   275 	originalUnicode[1]=0x2015;

   276 	test(characterSetConverter->ConvertFromUnicode(generatedGbk, originalUnicode)==0);

   277 	test(generatedGbk==_L8("\xa1\xaa\xa1\xaa"));

   279 	INFO_PRINTF1(_L("Testing truncated GBK sequences"));

   280 	originalGbk.Set(_L8("qwe\xb5"));

   281 	test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGbk, state)==1);

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

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

   284 	originalGbk.Set(_L8("qwe\x80"));

   285 	test(characterSetConverter->ConvertToUnicode(generatedUnicode, originalGbk, state)==1);

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

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

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

   289 	}

   291 CT_GBK::CT_GBK()

   292     {

   293     SetTestStepName(KTestStep_T_GBK);

   294     }

   296 TVerdict CT_GBK::doTestStepL()

   297     {

   298     SetTestStepResult(EFail);

   300     __UHEAP_MARK;

   301     TRAPD(error1, DoE32MainL());

   302     __UHEAP_MARKEND;

   304     if(error1 == KErrNone)

   305         {

   306         SetTestStepResult(EPass);

   307         }

   309     return TestStepResult();

   310     }

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