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

     1 /*

     2 * Copyright (c) 2000-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 */

    18 #include <e32std.h>

    19 #include <e32base.h>

    20 #include <f32file.h>

    21 #include <charconv.h>

    22 #include "t_eucjpdirectmap.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 KBufferLength=100;

    37 void CT_EUCJPDIRECTMAP::TestTruncatedConversionFromUnicodeToEucJpDirectmap(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode)

    38 	{

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

    40 		{

    41 		TBuf8<KBufferLength> generatedEucJpDirectmap;

    42 		const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedEucJpDirectmap, aOriginalUnicode.Left(i));

    43 		test(returnValue>=0);

    44 		TBuf8<KBufferLength> generatedsecondPartOfEucJpDirectmap;

    45 		test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfEucJpDirectmap, aOriginalUnicode.Mid(i-returnValue))==0);

    46 		generatedEucJpDirectmap.Append(generatedsecondPartOfEucJpDirectmap);

    47 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    48 		TBuf16<KBufferLength> generatedUnicode;

    49 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedEucJpDirectmap, state)==0);

    50 		test(generatedUnicode==aOriginalUnicode);

    51 		}

    52 	}

    54 void CT_EUCJPDIRECTMAP::TestSplittingConvertingFromUnicodeToEucJpDirectmap(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfEucJpDirectmap, const TDesC8& aExpectedEucJpDirectmap, const TDesC16& aOriginalUnicode)

    55 	{

    56 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

    57 	test(aMaximumLengthUpperLimit<=KBufferLength);

    58 	TUint8 eucJpDirectmapBuffer[KBufferLength];

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

    60 		{

    61 		TPtr8 generatedFirstPartOfEucJpDirectmap(eucJpDirectmapBuffer, i);

    62 		test(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfEucJpDirectmap, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit);

    63 		test(generatedFirstPartOfEucJpDirectmap==aExpectedEucJpDirectmap.Left(aExpectedLengthOfFirstPartOfEucJpDirectmap));

    64 		TBuf8<KBufferLength> generatedSecondPartOfEucJpDirectmap;

    65 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfEucJpDirectmap, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0);

    66 		test(generatedSecondPartOfEucJpDirectmap==aExpectedEucJpDirectmap.Mid(aExpectedLengthOfFirstPartOfEucJpDirectmap));

    67 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    68 		TBuf16<KBufferLength> generatedUnicode;

    69 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfEucJpDirectmap, state)==0);

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

    71 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

    72 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfEucJpDirectmap, state)==0);

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

    74 		generatedUnicode.Append(generatedSecondPartOfUnicode);

    75 		test(generatedUnicode==aOriginalUnicode);

    76 		}

    77 	}

    79 void CT_EUCJPDIRECTMAP::TestTruncatedConversionToUnicodeFromEucJpDirectmap(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalEucJpDirectmap)

    80 	{

    81 	for (TInt i=aOriginalEucJpDirectmap.Length(); i>=3; --i)

    82 		{

    83 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    84 		TBuf16<KBufferLength> generatedUnicode;

    85 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalEucJpDirectmap.Left(i), state);

    86 		test(returnValue>=0);

    87 		TBuf16<KBufferLength> generatedsecondPartOfUnicode;

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

    89 		generatedUnicode.Append(generatedsecondPartOfUnicode);

    90 		test(generatedUnicode==aExpectedUnicode);

    91 		}

    92 	}

    94 void CT_EUCJPDIRECTMAP::TestSplittingConvertingToUnicodeFromEucJpDirectmap(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfEucJpDirectmapBytesNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfUnicode, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalEucJpDirectmap)

    95 	{

    96 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

    97 	test(aMaximumLengthUpperLimit<=KBufferLength);

    98 	TUint16 unicodeBuffer[KBufferLength];

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

   100 		{

   101 		TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i);

   102 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   103 		test(aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalEucJpDirectmap, state)==aExpectedNumberOfEucJpDirectmapBytesNotConvertedAtSplit);

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

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

   106 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

   107 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalEucJpDirectmap.Right(aExpectedNumberOfEucJpDirectmapBytesNotConvertedAtSplit), state)==0);

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

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

   110 		TBuf8<KBufferLength> generatedEucJpDirectmap;

   111 		test(aCharacterSetConverter.ConvertFromUnicode(generatedEucJpDirectmap, generatedFirstPartOfUnicode)==0);

   112 		TBuf8<KBufferLength> generatedSecondPartOfEucJpDirectmap;

   113 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfEucJpDirectmap, generatedSecondPartOfUnicode)==0);

   114 		generatedEucJpDirectmap.Append(generatedSecondPartOfEucJpDirectmap);

   115 		test(generatedEucJpDirectmap==aOriginalEucJpDirectmap);

   116 		}

   117 	}

   119 void CT_EUCJPDIRECTMAP::TestIsIllFormedEucJpDirectmap(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC8& aEucJpDirectmap)

   120 	{

   121 	TBuf16<50> generatedUnicode;

   122 	TInt state=CCnvCharacterSetConverter::KStateDefault;

   123 	TPtrC8 remainderOfEucJpDirectmap(aEucJpDirectmap);

   124 	TInt lastReturnValue=KMaxTInt;

   125 	FOREVER

   126 		{

   127 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, remainderOfEucJpDirectmap, state);

   128 		if (returnValue==CCnvCharacterSetConverter::EErrorIllFormedInput)

   129 			{

   130 			break;

   131 			}

   132 		test(returnValue>0);

   133 		test(returnValue<lastReturnValue);

   134 		lastReturnValue=returnValue;

   135 		remainderOfEucJpDirectmap.Set(remainderOfEucJpDirectmap.Right(returnValue));

   136 		}

   137 	}

   139 void CT_EUCJPDIRECTMAP::DoE32MainL()

   140 	{

   141 	RFs fileServerSession;

   142 	CleanupClosePushL(fileServerSession);

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

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

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

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

   147 	TInt i;

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

   149 		{

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

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

   152 		TPtrC charactersSetName(charactersSet.Name());

   153 		if (charactersSet.NameIsFileName())

   154 			{

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

   156 			}

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

   158 		}

   159 	INFO_PRINTF1(_L("Testing EUC-JP (DirectMap) conversions "));

   160 	characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierEucJpDirectmap, *arrayOfCharacterSetsAvailable, fileServerSession);

   161 	//

   162 	INFO_PRINTF1(_L("Empty descriptor"));

   163 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 0, 10, 0, 0, KNullDesC8, KNullDesC16);

   164 	TestSplittingConvertingToUnicodeFromEucJpDirectmap(*characterSetConverter, 0, 10, 0, 0, KNullDesC16, KNullDesC8);

   165 	INFO_PRINTF1(_L("Testing converting to EUC-JP (DirectMap)"));

   166 	TBuf16<50> originalUnicode;

   167 	originalUnicode.Format(_L16("Some %c%c%c%c%c%c"), 0xff9a, 0xff70, 0x6f22, 0x5b57, 0x5379, 0x5dce);

   168 	const TPtrC8 expectedEucJpDirectmap(_S8("Some \x8e\xda\x8e\xb0\xb4\xc1\xbb\xfa\x8f\xb4\xc1\x8f\xbb\xfa"));

   169 	TestTruncatedConversionFromUnicodeToEucJpDirectmap(*characterSetConverter, originalUnicode);

   170 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 0, 0, 11, 0, expectedEucJpDirectmap, originalUnicode);

   171 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 1, 1, 10, 1, expectedEucJpDirectmap, originalUnicode);

   172 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 2, 2, 9, 2, expectedEucJpDirectmap, originalUnicode);

   173 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 3, 3, 8, 3, expectedEucJpDirectmap, originalUnicode);

   174 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 4, 4, 7, 4, expectedEucJpDirectmap, originalUnicode);

   175 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 5, 6, 6, 5, expectedEucJpDirectmap, originalUnicode);

   176 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 7, 8, 5, 7, expectedEucJpDirectmap, originalUnicode);

   177 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 9, 10, 4, 9, expectedEucJpDirectmap, originalUnicode);

   178 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 11, 12, 3, 11, expectedEucJpDirectmap, originalUnicode);

   179 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 13, 15, 2, 13, expectedEucJpDirectmap, originalUnicode);

   180 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 16, 18, 1, 16, expectedEucJpDirectmap, originalUnicode);

   181 	TestSplittingConvertingFromUnicodeToEucJpDirectmap(*characterSetConverter, 19, 30, 0, 19, expectedEucJpDirectmap, originalUnicode);

   182 	INFO_PRINTF1(_L("Testing converting to Unicode"));

   183 	const TPtrC8 originalEucJpDirectmap(_S8("pool\xbe\xae\xc3\xd3\x8e\xcc\x8e\xdf\x8e\xd9\x8f\xc0\xcd\x8f\xc8\xc5pool\x8e\xcc\x8e\xdf\x8e\xd9\xbe\xae\xc3\xd3\x8f\xc0\xcd\x8f\xc8\xc5\xbe\xae\xc3\xd3pool\x8f\xc0\xcd\x8f\xc8\xc5\x8e\xcc\x8e\xdf\x8e\xd9pool"));

   184 	TBuf16<50> expectedUnicode;

   185 	expectedUnicode.Format(_L16("pool%c%c%c%c%c%c%cpool%c%c%c%c%c%c%c%c%cpool%c%c%c%c%cpool"), 0x5c0f, 0x6c60, 0xff8c, 0xff9f, 0xff99, 0x641e, 0x6f0d, 0xff8c, 0xff9f, 0xff99, 0x5c0f, 0x6c60, 0x641e, 0x6f0d, 0x5c0f, 0x6c60, 0x641e, 0x6f0d, 0xff8c, 0xff9f, 0xff99);

   186 	TestTruncatedConversionToUnicodeFromEucJpDirectmap(*characterSetConverter, expectedUnicode, originalEucJpDirectmap);

   187 	TestTruncatedConversionToUnicodeFromEucJpDirectmap(*characterSetConverter, expectedUnicode.Mid(4, 2), originalEucJpDirectmap.Mid(4, 4));

   188 	TestTruncatedConversionToUnicodeFromEucJpDirectmap(*characterSetConverter, expectedUnicode.Mid(6, 3), originalEucJpDirectmap.Mid(8, 6));

   189 	TestTruncatedConversionToUnicodeFromEucJpDirectmap(*characterSetConverter, expectedUnicode.Mid(9, 2), originalEucJpDirectmap.Mid(14, 6));

   190 	static const TInt numberOfCharactersInEachHomogeneousRun[13]={4, 2, 3, 2, 4, 3, 2, 2, 2, 4, 2, 3, 4};

   191 	static const TInt numberOfBytesPerCharacterInEachHomogeneousRun[13]={1, 2, 2, 3, 1, 2, 2, 3, 2, 1, 3, 2, 1};

   192 	TInt e=64;

   193 	TInt u=0;

   194 	for (i=0; i<13; ++i)

   195 		{

   196 		TInt j;

   197 		for (j=0; j<numberOfCharactersInEachHomogeneousRun[i]; ++j, ++u, e-=numberOfBytesPerCharacterInEachHomogeneousRun[i])

   198 			{

   199 			TestSplittingConvertingToUnicodeFromEucJpDirectmap(*characterSetConverter, u, u, e, u, expectedUnicode, originalEucJpDirectmap);

   200 			}

   201 		}

   202 	test(e==0);

   203 	test(u==37);

   204 	TestSplittingConvertingToUnicodeFromEucJpDirectmap(*characterSetConverter, u, u+10, e, u, expectedUnicode, originalEucJpDirectmap);

   205 	INFO_PRINTF1(_L("Testing ill-formed EUC-JP (DirectMap)"));

   206 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1"));

   207 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1\xb2\xc3"));

   208 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1\xb2\x8e"));

   209 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1\xb2\x8f"));

   210 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1\xb2\x8f\xaa"));

   211 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8e\xd4\x8e"));

   212 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8e\xd4\x8f"));

   213 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8e\xd4\x8f\xbb"));

   214 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f\xe5\x8e"));

   215 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f\xe5\x8f"));

   216 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f\xe5\x8f\xcc"));

   217 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("xyz\x8e\xd4\x8e"));

   218 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("xyz\x8e\xd4\x8f"));

   219 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("xyz\x8e\xd4\x8f\xdd"));

   220 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("xyz\x8f\xe5\x8e"));

   221 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("xyz\x8f\xe5\x8f"));

   222 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("xyz\x8f\xe5\x8f\xee"));

   223 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8e "));

   224 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f "));

   225 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f\xf1 "));

   226 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8e\x41"));

   227 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f\x41"));

   228 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\x8f\xe2\x41"));

   229 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("amb\x8e "));

   230 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("amb\x8f "));

   231 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("amb\x8f\xf1 "));

   232 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("amb\x8e\x41"));

   233 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("amb\x8f\x41"));

   234 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("amb\x8f\xe2\x41"));

   235 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1 "));

   236 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("\xa1\x61"));

   237 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("eb\xa1 "));

   238 	TestIsIllFormedEucJpDirectmap(*characterSetConverter, _L8("eb\xa1\x61"));

   240 	const TPtrC8 originalEucJpDirectmapYen(_S8("pool\x5c"));

   241 	TBuf16<10> expectedUnicodeBackSlash;

   242 	expectedUnicodeBackSlash.Format(_L16("pool%c"), 0x005c);

   243     TInt state=CCnvCharacterSetConverter::KStateDefault;

   244     TBuf16<KBufferLength> generatedUnicodeBackSlash;

   245     test(characterSetConverter->ConvertToUnicode(generatedUnicodeBackSlash, originalEucJpDirectmapYen, state) == 0);

   246     test(generatedUnicodeBackSlash==expectedUnicodeBackSlash);

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

   249 	}

   251 CT_EUCJPDIRECTMAP::CT_EUCJPDIRECTMAP()

   252     {

   253     SetTestStepName(KTestStep_T_EUCJPDIRECTMAP);

   254     }

   256 TVerdict CT_EUCJPDIRECTMAP::doTestStepL()

   257     {

   258     SetTestStepResult(EFail);

   260     __UHEAP_MARK;

   261     TRAPD(error1, DoE32MainL());

   262     __UHEAP_MARKEND;

   264     if(error1 == KErrNone)

   265         {

   266         SetTestStepResult(EPass);

   267         }

   269     return TestStepResult();

   270     }

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