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 */

    19 #include <e32std.h>

    20 #include <e32base.h>

    21 #include <f32file.h>

    22 #include <charconv.h>

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

    37 const TInt KNotEnoughBufferLength=17;

    38 /**

    39 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0522

    40 @SYMTestCaseDesc        Tests for conversion from Unicode to ISO2022JP

    41 @SYMTestPriority        Medium

    42 @SYMTestActions         Tests for conversion from Unicode to ISO2022JP and back to Unicode

    43 @SYMTestExpectedResults Test must not fail

    44 @SYMREQ                 REQ0000

    45 */

    46 void CT_ISO2022JP::TestConversionFromUnicodeToIso(

    47                 CCnvCharacterSetConverter& aCharacterSetConverter,

    48                 const TDesC16& aOriginalUnicode)

    49  	{

    50 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0522 "));

    51  	TBuf8<KNotEnoughBufferLength> generatedIso2022Jp;

    52 	generatedIso2022Jp.FillZ(KNotEnoughBufferLength);

    53  	const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedIso2022Jp, aOriginalUnicode);

    54  	test(returnValue>=0);

    55  	TInt state=CCnvCharacterSetConverter::KStateDefault;

    56  	TBuf16<KBufferLength> generatedUnicode;

    57 	TInt testresult;

    58 	testresult=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedIso2022Jp, state);

    59  	test(testresult==0);

    60  //	test(generatedUnicode==aOriginalUnicode);

    61  	}

    62 /**

    63 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0523

    64 @SYMTestCaseDesc        Tests for truncated conversion from Unicode to ISO2022JP

    65 @SYMTestPriority        Medium

    66 @SYMTestActions         Tests for truncated conversion from Unicode to ISO2022JP and back to Unicode

    67 @SYMTestExpectedResults Test must not fail

    68 @SYMREQ                 REQ0000

    69 */

    70 void CT_ISO2022JP::TestTruncatedConversionFromUnicodeToIso2022Jp(

    71                 CCnvCharacterSetConverter& aCharacterSetConverter,

    72                 const TDesC16& aOriginalUnicode)

    73 	{

    74 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0523 "));

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

    76 		{

    77 		TBuf8<KBufferLength> generatedIso2022Jp;

    78 		const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedIso2022Jp, aOriginalUnicode.Left(i));

    79 		test(returnValue>=0);

    80 		TBuf8<KBufferLength> generatedsecondPartOfIso2022Jp;

    81 		test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfIso2022Jp, aOriginalUnicode.Mid(i-returnValue))==0);

    82 		generatedIso2022Jp.Append(generatedsecondPartOfIso2022Jp);

    83 		TInt state=CCnvCharacterSetConverter::KStateDefault;

    84 		TBuf16<KBufferLength> generatedUnicode;

    85 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedIso2022Jp, state)==0);

    86 		test(generatedUnicode==aOriginalUnicode);

    87 		}

    88 	}

    89 /**

    90 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0524

    91 @SYMTestCaseDesc        Splitting and converting from Unicode to ISO2022JP test

    92 @SYMTestPriority        Medium

    93 @SYMTestActions         Tests for conversion after splitting, from Unicode to ISO2022JP and back to Unicode

    94 @SYMTestExpectedResults Test must not fail

    95 @SYMREQ                 REQ0000

    96 */

    97 void CT_ISO2022JP::TestSplittingConvertingFromUnicodeToIso2022Jp(

    98                 CCnvCharacterSetConverter& aCharacterSetConverter,

    99                 TInt aMaximumLengthLowerLimit,

   100                 TInt aMaximumLengthUpperLimit,

   101                 TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit,

   102                 const TDesC8& aExpectedFirstPartOfIso2022Jp,

   103                 const TDesC8& aExpectedSecondPartOfIso2022Jp,

   104                 const TDesC16& aOriginalUnicode)

   105 	{

   106 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0524 "));

   107 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

   108 	test(aMaximumLengthUpperLimit<=KBufferLength);

   109 	TUint8 iso2022JpBuffer[KBufferLength];

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

   111 		{

   112 		TPtr8 generatedFirstPartOfIso2022Jp(iso2022JpBuffer, i);

   113 		test(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfIso2022Jp, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit);

   114 		test(generatedFirstPartOfIso2022Jp==aExpectedFirstPartOfIso2022Jp);

   115 		TBuf8<KBufferLength> generatedSecondPartOfIso2022Jp;

   116 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfIso2022Jp, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0);

   117 		test(generatedSecondPartOfIso2022Jp==aExpectedSecondPartOfIso2022Jp);

   118 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   119 		TBuf16<KBufferLength> generatedUnicode;

   120 		test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfIso2022Jp, state)==0);

   121 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

   122 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfIso2022Jp, state)==0);

   123 		generatedUnicode.Append(generatedSecondPartOfUnicode);

   124 		test(generatedUnicode==aOriginalUnicode);

   125 		}

   126 	}

   127 /**

   128 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0525

   129 @SYMTestCaseDesc        Tests for truncated conversion from ISO2022JP to Unicode test

   130 @SYMTestPriority        Medium

   131 @SYMTestActions         Tests for truncated conversion from ISO2022JP to Unicode and back to ISO2022JP

   132 @SYMTestExpectedResults Test must not fail

   133 @SYMREQ                 REQ0000

   134 */

   135 void CT_ISO2022JP::TestTruncatedConversionToUnicodeFromIso2022Jp(

   136                 CCnvCharacterSetConverter& aCharacterSetConverter,

   137                 const TDesC16& aExpectedUnicode,

   138                 const TDesC8& aOriginalIso2022Jp)

   139 	{

   140 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0525 "));

   141 	for (TInt i=aOriginalIso2022Jp.Length(); i>=3; --i) // 3 is the length of ISO-2022-JP's longest escape sequence

   142 		{

   143 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   144 		TBuf16<KBufferLength> generatedUnicode;

   145 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, aOriginalIso2022Jp.Left(i), state);

   146 		test(returnValue>=0);

   147 		TBuf16<KBufferLength> generatedsecondPartOfUnicode;

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

   149 		generatedUnicode.Append(generatedsecondPartOfUnicode);

   150 		test(generatedUnicode==aExpectedUnicode);

   151 		}

   152 	}

   153 /**

   154 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0526

   155 @SYMTestCaseDesc        Splitting and converting from ISO2022JP to Unicode test.

   156 @SYMTestPriority        Medium

   157 @SYMTestActions         Tests for conversion after splitting, from ISO2022JP to Unicode and back to ISO2022JP

   158 @SYMTestExpectedResults Test must not fail

   159 @SYMREQ                 REQ0000

   160 */

   161 void CT_ISO2022JP::TestSplittingConvertingToUnicodeFromIso2022Jp(

   162                 CCnvCharacterSetConverter& aCharacterSetConverter,

   163                 TInt aMaximumLengthLowerLimit,

   164                 TInt aMaximumLengthUpperLimit,

   165                 TInt aExpectedNumberOfIso2022JpBytesNotConvertedAtSplit,

   166                 TInt aExpectedLengthOfFirstPartOfUnicode,

   167                 const TDesC16& aExpectedUnicode,

   168                 const TDesC8& aOriginalIso2022Jp)

   169 	{

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

   171 	test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit);

   172 	test(aMaximumLengthUpperLimit<=KBufferLength);

   173 	TUint16 unicodeBuffer[KBufferLength];

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

   175 		{

   176 		TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i);

   177 		TInt state=CCnvCharacterSetConverter::KStateDefault;

   178 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalIso2022Jp, state);

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

   180 		test(returnValue==aExpectedNumberOfIso2022JpBytesNotConvertedAtSplit);

   181 		TBuf16<KBufferLength> generatedSecondPartOfUnicode;

   182 		test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalIso2022Jp.Right(aExpectedNumberOfIso2022JpBytesNotConvertedAtSplit), state)==0);

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

   184 		TBuf8<KBufferLength> generatedIso2022Jp;

   185 		test(aCharacterSetConverter.ConvertFromUnicode(generatedIso2022Jp, generatedFirstPartOfUnicode)==0);

   186 		TBuf8<KBufferLength> generatedSecondPartOfIso2022Jp;

   187 		test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfIso2022Jp, generatedSecondPartOfUnicode)==0);

   188 		generatedIso2022Jp.Append(generatedSecondPartOfIso2022Jp);

   189 		TBuf16<KBufferLength> regeneratedUnicode;

   190 		state=CCnvCharacterSetConverter::KStateDefault;

   191 		test(aCharacterSetConverter.ConvertToUnicode(regeneratedUnicode, generatedIso2022Jp, state)==0);

   192 		test(regeneratedUnicode==aExpectedUnicode);

   193 		state=CCnvCharacterSetConverter::KStateDefault;

   194 		test(aCharacterSetConverter.ConvertToUnicode(regeneratedUnicode, aOriginalIso2022Jp, state)==0);

   195 		test(regeneratedUnicode==aExpectedUnicode);

   196 		}

   197 	}

   198 /**

   199 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0527

   200 @SYMTestCaseDesc        Conversion of bad ISO2022JP format to Unicode test

   201 @SYMTestPriority        Medium

   202 @SYMTestActions         Tests to convert bad format ISO2022JP input to Unicode.

   203 @SYMTestExpectedResults Test must not fail

   204 @SYMREQ                 REQ0000

   205 */

   206 void CT_ISO2022JP::TestIsIllFormedIso2022Jp(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC8& aIso2022Jp)

   207 	{

   208 	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0527 "));

   209 	TBuf16<50> generatedUnicode;

   210 	TInt state=CCnvCharacterSetConverter::KStateDefault;

   211 	TPtrC8 remainderOfIso2022Jp(aIso2022Jp);

   212 	TInt lastReturnValue=KMaxTInt;

   213 	FOREVER

   214 		{

   215 		const TInt returnValue=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, remainderOfIso2022Jp, state);

   216 		if (returnValue==CCnvCharacterSetConverter::EErrorIllFormedInput)

   217 			{

   218 			break;

   219 			}

   220 		test(returnValue>0);

   221 		test(returnValue<lastReturnValue);

   222 		lastReturnValue=returnValue;

   223 		remainderOfIso2022Jp.Set(remainderOfIso2022Jp.Right(returnValue));

   224 		}

   225 	}

   226 /**

   227 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0528

   228 @SYMTestCaseDesc        ISO2022JP to Unicode and Unicode to ISO2022JP conversion tests

   229 @SYMTestPriority        Medium

   230 @SYMTestActions         Call up conversion of ISO2022JP to Unicode test functions

   231 @SYMTestExpectedResults Test must not fail

   232 @SYMREQ                 REQ0000

   233 */

   234 void CT_ISO2022JP::DoE32MainL()

   235 	{

   236     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0528 "));

   237 	RFs fileServerSession;

   238 	CleanupClosePushL(fileServerSession);

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

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

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

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

   243 	TInt i;

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

   245 		{

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

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

   248 		TPtrC charactersSetName(charactersSet.Name());

   249 		if (charactersSet.NameIsFileName())

   250 			{

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

   252 			}

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

   254 		}

   255 	INFO_PRINTF1(_L("Testing ISO-2022-JP conversions"));

   256 	characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierIso2022Jp, *arrayOfCharacterSetsAvailable, fileServerSession);

   257 	//

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

   259 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 0, 10, 0, KNullDesC8, KNullDesC8, KNullDesC16);

   260 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 0, 10, 0, 0, KNullDesC16, KNullDesC8);

   261 	INFO_PRINTF1(_L("Testing converting to ISO-2022-JP"));

   263 	_LIT(KTestUnicode,">.@>0l90");

   264 	_LIT(KTestUnicode2,"\x0393\x03b1\x03c3\x03bf\x03c5\x3055\x3088");

   265  	TestConversionFromUnicodeToIso(*characterSetConverter, KTestUnicode2);

   266  	TestConversionFromUnicodeToIso(*characterSetConverter, KTestUnicode);

   268 	TBuf16<50> originalUnicode;

   269 	originalUnicode.Format(_L16("%c%c%c%c%c\xa5\\%c%c%c%c%c"), 0x0393, 0x03b1, 0x03c3, 0x03bf, 0x03c5, 0x3055, 0x3088, 0x3046, 0x306a, 0x3089);

   270 	TestTruncatedConversionFromUnicodeToIso2022Jp(*characterSetConverter, originalUnicode);

   271 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 3, 7, 12, _L8(""), _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   272 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 8, 9, 11, _L8("\x1b\x24\x42\x26\x23\x1b\x28\x42"), _L8("\x1b\x24\x42\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   273 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 10, 11, 10, _L8("\x1b\x24\x42\x26\x23\x26\x41\x1b\x28\x42"), _L8("\x1b\x24\x42\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   274 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 12, 13, 9, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x1b\x28\x42"), _L8("\x1b\x24\x42\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   275 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 14, 15, 8, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x1b\x28\x42"), _L8("\x1b\x24\x42\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   276 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 16, 19, 7, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x42"), _L8("\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   277     TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 20, 23, 6, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42"), _L8("\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   278 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 24, 28, 5, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\"), _L8("\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   279 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 29, 30, 4, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x1b\x28\x42"), _L8("\x1b\x24\x42\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   280 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 31, 32, 3, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x1b\x28\x42"), _L8("\x1b\x24\x42\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   281 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 33, 34, 2, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x1b\x28\x42"), _L8("\x1b\x24\x42\x24\x4a\x24\x69\x1b\x28\x42"), originalUnicode);

   282 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 35, 36, 1, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x1b\x28\x42"), _L8("\x1b\x24\x42\x24\x69\x1b\x28\x42"), originalUnicode);

   283 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 37, 50, 0, _L8("\x1b\x24\x42\x26\x23\x26\x41\x26\x52\x26\x4f\x26\x54\x1b\x28\x4a\\\x1b\x28\x42\\\x1b\x24\x42\x24\x35\x24\x68\x24\x26\x24\x4a\x24\x69\x1b\x28\x42"), KNullDesC8, originalUnicode);

   284 	originalUnicode.Format(_L16("%cX%cY%cZ"), 0x6153, 0x6376, 0x65d9);

   285 	TestTruncatedConversionFromUnicodeToIso2022Jp(*characterSetConverter, originalUnicode);

   286 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 3, 7, 6, _L8(""), _L8("\x1b\x24\x42XX\x1b\x28\x42X\x1b\x24\x42YY\x1b\x28\x42Y\x1b\x24\x42ZZ\x1b\x28\x42Z"), originalUnicode);

   287 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 8, 11, 5, _L8("\x1b\x24\x42XX\x1b\x28\x42"), _L8("X\x1b\x24\x42YY\x1b\x28\x42Y\x1b\x24\x42ZZ\x1b\x28\x42Z"), originalUnicode);

   288 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 12, 16, 4, _L8("\x1b\x24\x42XX\x1b\x28\x42X"), _L8("\x1b\x24\x42YY\x1b\x28\x42Y\x1b\x24\x42ZZ\x1b\x28\x42Z"), originalUnicode);

   289 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 17, 20, 3, _L8("\x1b\x24\x42XX\x1b\x28\x42X\x1b\x24\x42YY\x1b\x28\x42"), _L8("Y\x1b\x24\x42ZZ\x1b\x28\x42Z"), originalUnicode);

   290 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 21, 25, 2, _L8("\x1b\x24\x42XX\x1b\x28\x42X\x1b\x24\x42YY\x1b\x28\x42Y"), _L8("\x1b\x24\x42ZZ\x1b\x28\x42Z"), originalUnicode);

   291 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 26, 29, 1, _L8("\x1b\x24\x42XX\x1b\x28\x42X\x1b\x24\x42YY\x1b\x28\x42Y\x1b\x24\x42ZZ\x1b\x28\x42"), _L8("Z"), originalUnicode);

   292 	TestSplittingConvertingFromUnicodeToIso2022Jp(*characterSetConverter, 30, 40, 0, _L8("\x1b\x24\x42XX\x1b\x28\x42X\x1b\x24\x42YY\x1b\x28\x42Y\x1b\x24\x42ZZ\x1b\x28\x42Z"), KNullDesC8, originalUnicode);

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

   294 	const TPtrC8 originalIso2022Jp(_S8("\x1b\x24\x40\x1b\x28\x4aMy name is \x1b\x28\x4a\x1b\x28\x42\x1b\x24\x40\x25\x47\x25\x23\x25\x53\x25\x45\x1b\x28\x4a in \x1b\x24\x42\x46\x7c\x4b\x5c\x38\x6c\x1b\x28\x42\\~\x1b\x28\x4a\\~"));

   295 	TBuf16<50> expectedUnicode;

   296 	expectedUnicode.Format(_L16("My name is %c%c%c%c in %c%c%c\\~%c%c"), 0x30c7, 0x30a3, 0x30d3, 0x30c5, 0x65e5, 0x672c, 0x8a9e, 0x00a5, 0x203e);

   297 	TestTruncatedConversionToUnicodeFromIso2022Jp(*characterSetConverter, expectedUnicode, originalIso2022Jp);

   298 	TestTruncatedConversionToUnicodeFromIso2022Jp(*characterSetConverter, _L16(" Hello"), _L8("\x1b\x24\x42\x1b\x28\x4a\x1b\x24\x42\x1b\x28\x4a\x1b\x24\x42\x1b\x28\x4a Hello"));

   299 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 0, 0, 60, 0, expectedUnicode, originalIso2022Jp);

   300 	for (i=1; i<=10; ++i)

   301 		{

   302 		TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, i, i, 54-i, i, expectedUnicode, originalIso2022Jp);

   303 		}

   304 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 11, 11, 34, 11, expectedUnicode, originalIso2022Jp);

   305 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 12, 12, 32, 12, expectedUnicode, originalIso2022Jp);

   306 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 13, 13, 30, 13, expectedUnicode, originalIso2022Jp);

   307 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 14, 14, 28, 14, expectedUnicode, originalIso2022Jp);

   308 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 15, 15, 23, 15, expectedUnicode, originalIso2022Jp);

   309 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 16, 16, 22, 16, expectedUnicode, originalIso2022Jp);

   310 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 17, 17, 21, 17, expectedUnicode, originalIso2022Jp);

   311 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 18, 18, 20, 18, expectedUnicode, originalIso2022Jp);

   312 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 19, 19, 16, 19, expectedUnicode, originalIso2022Jp);

   313 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 20, 20, 14, 20, expectedUnicode, originalIso2022Jp);

   314 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 21, 21, 12, 21, expectedUnicode, originalIso2022Jp);

   315 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 22, 22, 7, 22, expectedUnicode, originalIso2022Jp);

   316 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 23, 23, 6, 23, expectedUnicode, originalIso2022Jp);

   317 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 24, 24, 2, 24, expectedUnicode, originalIso2022Jp);

   318 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 25, 25, 1, 25, expectedUnicode, originalIso2022Jp);

   319 	TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, 26, 40, 0, 26, expectedUnicode, originalIso2022Jp);

   320 	INFO_PRINTF1(_L("Testing the default ISO-2022-JP state"));

   321 	for (i=0; i<=6; ++i)

   322 		{

   323 		TestSplittingConvertingToUnicodeFromIso2022Jp(*characterSetConverter, i, i, 6-i, i, _L16("Hello\xa5"), _L8("Hello\\"));

   324 		}

   325 	INFO_PRINTF1(_L("Testing ill-formed ISO-2022-JP"));

   326 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b\x24\x42\x21\x1b\x28\x4a def"));

   327 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b\x24\x42\x21\x21\x21\x1b\x28\x4a def"));

   328 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b\x24\x42\x21\x21\x21\x21\x21\x1b\x28\x4a def"));

   329 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b"));

   330 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b\x24"));

   331 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b\x24\xff"));

   332 	TestIsIllFormedIso2022Jp(*characterSetConverter, _L8("abc \x1b\x26\x40"));

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

   334 	}

   336 CT_ISO2022JP::CT_ISO2022JP()

   337     {

   338     SetTestStepName(KTestStep_T_ISO2022JP);

   339     }

   341 TVerdict CT_ISO2022JP::doTestStepL()

   342     {

   343     SetTestStepResult(EFail);

   345     __UHEAP_MARK;

   346     TRAPD(error1, DoE32MainL());

   347     __UHEAP_MARKEND;

   349     if(error1 == KErrNone)

   350         {

   351         SetTestStepResult(EPass);

   352         }

   354     return TestStepResult();

   355     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--