Symaptic: os/textandloc/charconvfw/fatfilenameconversionplugins/test/T

     1 /*

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

    20 #include <e32des8.h>

    21 #include <hal.h>

    23 #define test(cond)                                          \

    24     {                                                       \

    25     TBool __bb = (cond);                                    \

    26     TEST(__bb);                                             \

    27     if (!__bb)                                              \

    28         {                                                   \

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

    30         User::Leave(1);                                     \

    31         }                                                   \

    32     }

    35 const TInt MaxCount = 10000;    // iteration number for performance tests

    37 // cp54936 should be faster than cp936

    38 _LIT(KName936,"CP936");

    39 const TUid KPluginUid936={0x10206A91};

    42 _LIT(KName,"CP54936");

    43 const TUid KPluginUid={0x1028703b};

    46 void CT_CP54936::TestOut(const TDesC16 &des)

    47 	{

    48 	for (TInt i=0; i<des.Length(); i++)

    49 	    INFO_PRINTF2(_L("%04X "), des[i]);

    50 	}

    52 void CT_CP54936::TestOut(const TDesC8 &des)

    53 	{

    54 	for (TInt i=0; i<des.Length(); i++)

    55 	    INFO_PRINTF2(_L("%02X "), des[i]);

    56 	}

    58 // Used for supressing warning in OOM tests

    59 #define __UNUSED_VAR(var) var = var

    61 /**

    62 @SYMTestCaseID          SYSLIB-FATCHARSETCONV-CT-1778

    63 @SYMTestCaseDesc	    Tests API behaviours of UnicodeConv class

    64 @SYMTestPriority 	    High

    65 @SYMTestActions  	    Tests for conversions from/to Unicode, using a function pointer

    66 @SYMTestExpectedResults Test must not fail

    67 */

    68 void CT_CP54936::TestL()

    69 	{

    70     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-FATCHARSETCONV-CT-1778 "));

    71 	RLibrary lib;

    73 	const TUidType serverUid(KNullUid,KNullUid,KPluginUid);

    74 	// load the dll

    75 	TInt returnValue = lib.Load(KName,serverUid);

    76 	test(returnValue==0);

    78 	// get a pointer to the specified ordinal function and call it

    79 	TLibraryFunction function1 = lib.Lookup(1);

    80 	TLibraryFunction function2 = lib.Lookup(2);

    81 	TLibraryFunction function3 = lib.Lookup(3);

    83 	//cast the function pointer f to a function of type void with two arguments

    84 	typedef void (*TConvertFromUnicodeL)(TDes8&, const TDesC16&);

    85 	TConvertFromUnicodeL aConvertFromUnicodeL = reinterpret_cast <TConvertFromUnicodeL> (function1);

    87 	typedef void (*TConvertToUnicodeL)(TDes16&, const TDesC8&);

    88 	TConvertToUnicodeL aConvertToUnicodeL = reinterpret_cast <TConvertToUnicodeL> (function2);

    90 	typedef TBool (*TIsLegalShortNameCharacter)(TUint);

    91 	TIsLegalShortNameCharacter aIsLegalShortNameCharacter = reinterpret_cast <TIsLegalShortNameCharacter> (function3);

    93 	// from Test Analysis:

    94 	// p1:		0x40 -> 0x40

    95 	// p2:		0x24 -> 0x24

    96 	// p3:		0x706C -> 0xECE1

    97 	// p4:		0x4E96 -> 0x8181

    98 	// p5:		0x20AC -> 0xA2E3

    99 	// p6:		0x3622 -> 0x8230A730, 0x060C -> 0x81318132

   100 	// p7:		0x201AD (0xD840 0xDDAD) -> 0x9532AD35

   101 	// p10-p15:	N/A

   102 	// p20-p22: N/A

   103 	// p30:		0x32FF -> 0x8139D633

   104 	// p31:		0x10500 (0xD801 0xDD00) -> 0x90318330

   105 	//			0xFFFF -> 0x8431A439

   106 	_LIT16(Uni_1, "\x0040\xD840\x0024\x060C\x706C\x4E96\x20AC\x3622\xD840\xDDAD\x32FF\xD801\xDD00\xDC00\xFFFF");

   107 	_LIT8(CP54936_1, "\x40\x5F\x24\x81\x31\x81\x32\xEC\xE1\x81\x81\xA2\xE3\x82\x30\xA7\x30\x95\x32\xAD\x35\x81\x39\xD6\x33\x90\x31\x83\x30\x5F\x84\x31\xA4\x39");

   109 	TBuf8<200> foreign1;

   110 	TBuf16<200> unicode2;

   112 	const TDesC16& unicode1(Uni_1);

   113 	INFO_PRINTF1(_L("source: "));	TestOut(unicode1);	INFO_PRINTF1(_L("\n"));

   114 	INFO_PRINTF1(_L("expect: "));	TestOut(CP54936_1);	INFO_PRINTF1(_L("\n"));

   115 	//TRAPD(err, (*aConvertFromUnicodeL)(foreign1, unicode1));

   116 	(*aConvertFromUnicodeL)(foreign1, unicode1); 	//testing conversion from Unicode

   117 	INFO_PRINTF1(_L("result: "));	TestOut(foreign1);	INFO_PRINTF1(_L("\n"));

   118 	TInt error = foreign1.Compare(CP54936_1);

   119 	test(error==0);

   120 	foreign1.Zero();

   122 	// from Test Analysis:

   123 	// p1:		0x40

   124 	// p2:		0x24

   125 	// p3:		0x706C <- 0xECE1

   126 	// p4:		0x4E96 <- 0x8181

   127 	// p5:		0x20AC <- 0xA2E3

   128 	// p6:		0x3622 <- 0x8230A730, 0x060C <- 0x81318132

   129 	// p7:		0x201AD (0xD840 0xDDAD) <- 0x9532AD35

   130 	// p10:		//0x0E -> 0xFFFD

   131 	// p11:		//0xA0 -> 0xFFFD

   132 	// p12:		0xA1A0 -> 0xE525

   133 	// p13:		0xA07F -> 0xFFFD

   134 	// p14:		0x95328230 -> 0x1FFFA (0xD83F 0xDFFA) //0xFFFD

   135 	// p15:		0x8130813A -> 0xFFFD

   136 	// p20-p22:	N/A

   137 	// p30-p31:	N/A

   138 	_LIT16(Uni_2, "\x0040\x0024\x706C\x4E96\x20AC\x3622\x060C\xD840\xDDAD\xE525\xFFFD\xD83F\xDFFA\xFFFD");

   139 	_LIT8(CP54936_2, "\x40\x24\xEC\xE1\x81\x81\xA2\xE3\x82\x30\xA7\x30\x81\x31\x81\x32\x95\x32\xAD\x35\xA1\xA0\xA0\x7F\x95\x32\x82\x30\x81\x30\x81\x3A");

   141 	const TDesC8& foreign2(CP54936_2);

   142 	INFO_PRINTF1(_L("source: "));	TestOut(foreign2);	INFO_PRINTF1(_L("\n"));

   143 	INFO_PRINTF1(_L("expect: "));	TestOut(Uni_2);		INFO_PRINTF1(_L("\n"));

   144 	//TRAP(err, (*aConvertToUnicodeL)(unicode2,foreign2));

   145 	(*aConvertToUnicodeL)(unicode2,foreign2);//); 	//testing conversion to Unicode

   146 	INFO_PRINTF1(_L("result: "));	TestOut(unicode2);	INFO_PRINTF1(_L("\n"));

   147 	error = unicode2.Compare(Uni_2);

   148 	test(error==0);

   149 	unicode2.Zero();

   152 	//testing for legal short name character

   153 	TInt result = (*aIsLegalShortNameCharacter)(0x005F); //testing for existent character

   154 	test(result==1);

   155 	result = (*aIsLegalShortNameCharacter)(0x003F); //testing for illegal character

   156 	test(result==0);

   157 	result = (*aIsLegalShortNameCharacter)(0x2999);

   158 	test(result==1);

   159 	result = (*aIsLegalShortNameCharacter)(0x4E02); //testing for a double byte character

   160 	test(result==1);

   162 	lib.Close();

   163 	}

   165 /**

   166 @SYMTestCaseID          SYSLIB-FATCHARSETCONV-CT-1847-0001

   167 @SYMTestCaseDesc	    Tests API behaviours of UnicodeConv class as part of INC090073

   168 @SYMTestPriority 	    High

   169 @SYMTestActions  	    Tests for correct character conversion on certain chinese characters for CP936

   170 @SYMTestExpectedResults Test must not fail

   171 */

   172 void CT_CP54936::TestINC090073L()

   173 	{

   174     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-FATCHARSETCONV-CT-1847-0001 "));

   176  	_LIT16(unicode, "\x7CCD\x74EF\x8026\x8F8F\x94F3\x7633\x6DFC\x9785\x7F81\x7A37\x61A9\x80B1\x86A3\x89E5\x80F2\x9B48\x9E47\x6C19\x7B71\x946B\x6B46\x6615");

   177 	_LIT8(CP932Code, "\xF4\xD9\xEA\xB1\xF1\xEE\xEA\xA3\xEF\xA5\xF1\xAC\xED\xB5\xF7\xB1\xEE\xBF\xF0\xA2\xED\xAC\xEB\xC5\xF2\xBC\xF6\xA1\xEB\xDC\xF7\xCC\xF0\xC2\xEB\xAF\xF3\xE3\xF6\xCE\xEC\xA7\xEA\xBF");

   179 	RLibrary lib;

   181 	const TUidType serverUid(KNullUid,KNullUid,KPluginUid);

   182 	// load the dll

   183 	TInt returnValue = lib.Load(KName,serverUid);

   184 	test(returnValue==0);

   186 	// get a pointer to the specified ordinal function and call it

   187 	TLibraryFunction function1 = lib.Lookup(1);

   190 	//cast the function pointer f to a function of type void with two arguments

   191 	typedef void (*TConvertFromUnicodeL)(TDes8&, const TDesC16&);

   192 	TConvertFromUnicodeL aConvertFromUnicodeL = reinterpret_cast <TConvertFromUnicodeL> (function1);

   194 	TBuf8<50> foreign1;

   196 	foreign1.Zero();

   197 	const TDesC16& unicode1(unicode);

   198 	TRAPD(err,(*aConvertFromUnicodeL)(foreign1, unicode1)); 	//testing conversion from Unicode

   199 	test(err==0);

   200 	TInt error = foreign1.Compare(CP932Code);

   201 	test(error==0);

   202 	foreign1.Zero();

   204 	lib.Close();

   205 	}

   207 void CT_CP54936::OOMTestL()

   208 	{

   209     INFO_PRINTF1(_L("OOM testing"));

   210 	TInt err, tryCount = 0;

   211 	do

   212 		{

   213 			__UHEAP_MARK;

   214   		// find out the number of open handles

   215 		TInt startProcessHandleCount;

   216 		TInt startThreadHandleCount;

   217 		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

   219 			// Setting Heap failure for OOM test

   220 		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

   222 		TRAP(err,TestL());

   224 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   226 		// check that no handles have leaked

   227 		TInt endProcessHandleCount;

   228 		TInt endThreadHandleCount;

   229 		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

   231 		test(startProcessHandleCount == endProcessHandleCount);

   232 		test(startThreadHandleCount  == endThreadHandleCount);

   234 		__UHEAP_MARKEND;

   235 		}while (err == KErrNoMemory);

   237 	test(err == KErrNone);

   238 	INFO_PRINTF2(_L("- server succeeded at heap failure rate of %i\n"), tryCount);

   239 	}

   242 void CT_CP54936::PerformanceTest1L()

   243 	{

   244     INFO_PRINTF1(_L("Performance test 1 (comparing with cp936)"));

   245 	RLibrary lib936;

   246 	RLibrary lib54936;

   248 	const TUidType serverUid936(KNullUid,KNullUid,KPluginUid936);

   249 	const TUidType serverUid54936(KNullUid,KNullUid,KPluginUid);

   251 	// load the dll

   252 	TInt returnValue = lib936.Load(KName936,serverUid936);

   253 	test(returnValue==0);

   254 	TInt returnValue2 = lib54936.Load(KName,serverUid54936);

   255 	test(returnValue2==0);

   257 	// get a pointer to the specified ordinal function and call it

   258 	TLibraryFunction function9361 = lib936.Lookup(1);

   259 	TLibraryFunction function9362 = lib936.Lookup(2);

   260 	TLibraryFunction function9363 = lib936.Lookup(3);

   261 	TLibraryFunction function549361 = lib54936.Lookup(1);

   262 	TLibraryFunction function549362 = lib54936.Lookup(2);

   263 	TLibraryFunction function549363 = lib54936.Lookup(3);

   265 	//cast the function pointer f to a function of type void with two arguments

   266 	typedef void (*TConvertFromUnicodeL)(TDes8&, const TDesC16&);

   267 	TConvertFromUnicodeL aConvertFromUnicode936L = reinterpret_cast <TConvertFromUnicodeL> (function9361);

   268 	TConvertFromUnicodeL aConvertFromUnicode54936L = reinterpret_cast <TConvertFromUnicodeL> (function549361);

   270 	typedef void (*TConvertToUnicodeL)(TDes16&, const TDesC8&);

   271 	TConvertToUnicodeL aConvertToUnicode936L = reinterpret_cast <TConvertToUnicodeL> (function9362);

   272 	TConvertToUnicodeL aConvertToUnicode54936L = reinterpret_cast <TConvertToUnicodeL> (function549362);

   274 	// timer

   275 	TInt count;

   276 	TChar res2;

   277 	TBuf<256> msg;

   278 	TInt fastTimerFreq;

   279 	HAL::Get(HALData::EFastCounterFrequency, fastTimerFreq);

   280 	TReal ticksPerMicroSec = 1.0E-6 * fastTimerFreq;

   281 	TUint prevTime;

   282 	TUint timeDiff;

   283 	TReal64 fsSessionMicroSecs;

   285 	_LIT16(Uni_1, "\x0053\x0059\x004D\x3125\x3122\x9673\xFA29");

   286 	_LIT8(CP54936_1, "\x53\x59\x4D\xA8\xE5\xA8\xE2\xEA\x90\xFE\x4F");

   287 	TBuf8<20> foreign1;

   288 	TBuf16<20> unicode2;

   289 	const TDesC16& unicode1(Uni_1);

   290 	TInt error;

   292 //////////////////////////////////////////////////////////////////////////////

   293 //////////////////////////////////////////////////////////////////////////////

   294 	// 1, unicode -> 936

   295 	// test result: 1448 ms for 100000 iterations

   296 	INFO_PRINTF1(_L("unicode --> 936:\n"));

   297 	INFO_PRINTF1(_L("        source: "));	TestOut(unicode1);	INFO_PRINTF1(_L("\n"));

   298 	INFO_PRINTF1(_L("        expect: "));	TestOut(CP54936_1);	INFO_PRINTF1(_L("\n"));

   299 	prevTime = User::FastCounter();

   300 	for (count=0; count<MaxCount; count++)

   301 		{

   302 		foreign1.Zero();

   303 		(*aConvertFromUnicode936L)(foreign1, unicode1);

   304 		}

   305 	timeDiff = User::FastCounter() - prevTime;

   306 	fsSessionMicroSecs = timeDiff / (ticksPerMicroSec);

   307 	msg.Format(_L("                    %10.2lf us, "), fsSessionMicroSecs);

   308 	INFO_PRINTF1(_L("        result: "));	TestOut(foreign1);	INFO_PRINTF1(_L("\n"));

   309 	INFO_PRINTF1(msg);

   310 	error = foreign1.Compare(CP54936_1);

   311 	test(error==0);

   312 	foreign1.Zero();

   313 	INFO_PRINTF1(_L("\n"));

   315 	// 2, unicode -> 54936

   316 	// test result: 44 ms for 100000 iterations

   317 	INFO_PRINTF1(_L("unicode --> 54936:\n"));

   318 	INFO_PRINTF1(_L("        source: "));	TestOut(unicode1);	INFO_PRINTF1(_L("\n"));

   319 	INFO_PRINTF1(_L("        expect: "));	TestOut(CP54936_1);	INFO_PRINTF1(_L("\n"));

   320 	prevTime = User::FastCounter();

   321 	for (count=0; count<MaxCount; count++)

   322 		{

   323 		foreign1.Zero();

   324 		(*aConvertFromUnicode54936L)(foreign1, unicode1);

   325 		}

   326 	timeDiff = User::FastCounter() - prevTime;

   327 	fsSessionMicroSecs = timeDiff / (ticksPerMicroSec);

   328 	msg.Format(_L("                    %10.2lf us, "), fsSessionMicroSecs);

   329 	INFO_PRINTF1(_L("        result: "));	TestOut(foreign1);	INFO_PRINTF1(_L("\n"));

   330 	INFO_PRINTF1(msg);

   331 	error = foreign1.Compare(CP54936_1);

   332 	test(error==0);

   333 	foreign1.Zero();

   334 	INFO_PRINTF1(_L("\n"));

   336 //////////////////////////////////////////////////////////////////////////////

   337 //////////////////////////////////////////////////////////////////////////////

   338 	_LIT16(Uni_2, "\x0032\xFFFD\x7FB1\x0032\xFFFD\x7FB1\x7FB1");

   339 	_LIT8(CP54936_2, "\x32\xC1\x7F\xC1\x7E\x32\xC1\x7F\xC1\x7E\xC1\x7E");

   340 	const TDesC8& foreign2(CP54936_2);

   342 	// 3, 936 -> unicode

   343 	// test result: 89 ms for 100000 iterations

   344 	INFO_PRINTF1(_L("936 ---> unicode:\n"));

   345 	INFO_PRINTF1(_L("        source: "));	TestOut(foreign2);	INFO_PRINTF1(_L("\n"));

   346 	INFO_PRINTF1(_L("        expect: "));	TestOut(Uni_2);		INFO_PRINTF1(_L("\n"));

   347 	prevTime = User::FastCounter();

   348 	for (count=0; count<MaxCount; count++)

   349 		{

   350 		unicode2.Zero();

   351 		(*aConvertToUnicode936L)(unicode2,foreign2);

   352 		}

   353 	timeDiff = User::FastCounter() - prevTime;

   354 	fsSessionMicroSecs = timeDiff / (ticksPerMicroSec);

   355 	msg.Format(_L("                    %10.2lf us, "), fsSessionMicroSecs);

   356 	INFO_PRINTF1(_L("        result: "));	TestOut(unicode2);	INFO_PRINTF1(_L("\n"));

   357 	INFO_PRINTF1(msg);

   358 	error = unicode2.Compare(Uni_2);

   359 	test(error==0);

   360 	unicode2.Zero();

   361 	INFO_PRINTF1(_L("\n"));

   363 	// 4, 54936 -> unicode

   364 	// test result: 36 ms for 100000 iterations

   365 	INFO_PRINTF1(_L("54936 ---> unicode:\n"));

   366 	INFO_PRINTF1(_L("        source: "));	TestOut(foreign2);	INFO_PRINTF1(_L("\n"));

   367 	INFO_PRINTF1(_L("        expect: "));	TestOut(Uni_2);		INFO_PRINTF1(_L("\n"));

   368 	prevTime = User::FastCounter();

   369 	for (count=0; count<MaxCount; count++)

   370 		{

   371 		unicode2.Zero();

   372 		(*aConvertToUnicode54936L)(unicode2,foreign2);

   373 		}

   374 	timeDiff = User::FastCounter() - prevTime;

   375 	fsSessionMicroSecs = timeDiff / (ticksPerMicroSec);

   376 	msg.Format(_L("                    %10.2lf us, "), fsSessionMicroSecs);

   377 	INFO_PRINTF1(_L("        result: "));	TestOut(unicode2);	INFO_PRINTF1(_L("\n"));

   378 	INFO_PRINTF1(msg);

   379 	error = unicode2.Compare(Uni_2);

   380 	test(error==0);

   381 	unicode2.Zero();

   382 	INFO_PRINTF1(_L("\n"));

   384 	lib936.Close();

   385 	lib54936.Close();

   387 //	INFO_PRINTF1(_L("Press any key...\n"));

   388 //	test.Getch();

   389 	}

   392 // performance when converting mixed data.

   393 // just for reference.

   394 // ideally, the test result should be similar to that in PerformanceTest1()

   395 void CT_CP54936::PerformanceTest2L()

   396 	{

   397     INFO_PRINTF1(_L("Performance test 2 (reference)"));

   398 	RLibrary lib54936;

   399 	const TUidType serverUid54936(KNullUid,KNullUid,KPluginUid);

   401 	// load the dll

   402 	TInt returnValue2 = lib54936.Load(KName,serverUid54936);

   403 	test(returnValue2==0);

   405 	// get a pointer to the specified ordinal function and call it

   406 	TLibraryFunction function549361 = lib54936.Lookup(1);

   407 	TLibraryFunction function549362 = lib54936.Lookup(2);

   408 	TLibraryFunction function549363 = lib54936.Lookup(3);

   410 	//cast the function pointer f to a function of type void with two arguments

   411 	typedef void (*TConvertFromUnicodeL)(TDes8&, const TDesC16&);

   412 	TConvertFromUnicodeL aConvertFromUnicode54936L = reinterpret_cast <TConvertFromUnicodeL> (function549361);

   414 	typedef void (*TConvertToUnicodeL)(TDes16&, const TDesC8&);

   415 	TConvertToUnicodeL aConvertToUnicode54936L = reinterpret_cast <TConvertToUnicodeL> (function549362);

   417 	// timer

   418 	TInt count;

   419 	TBuf<256> msg;

   420 	TInt fastTimerFreq;

   421 	HAL::Get(HALData::EFastCounterFrequency, fastTimerFreq);

   422 	TReal ticksPerMicroSec = 1.0E-6 * fastTimerFreq;

   423 	TUint prevTime;

   424 	TUint timeDiff;

   425 	TReal64 fsSessionMicroSecs;

   427 //////////////////////////////////////////////////////////////////////////////

   428 //////////////////////////////////////////////////////////////////////////////

   429 	_LIT16(Uni_1, "\x0053\x0059\x004D\x3125\x3122\x9673\xFA29\x060C\xD840\xDC00");

   430 	_LIT8(CP54936_1, "\x53\x59\x4D\xA8\xE5\xA8\xE2\xEA\x90\xFE\x4F\x81\x31\x81\x32\x95\x32\x82\x36");

   431 	TBuf8<200> foreign1;

   432 	TBuf16<200> unicode2;

   433 	const TDesC16& unicode1(Uni_1);

   434 	TInt error;

   436 	// 2, unicode -> 54936

   437 	// test result: 130 ms for 100000 iterations (44 ms if one huge table for BMP characters)

   438 	INFO_PRINTF1(_L("unicode --> 54936:\n"));

   439 	INFO_PRINTF1(_L("        source: "));	TestOut(unicode1);	INFO_PRINTF1(_L("\n"));

   440 	INFO_PRINTF1(_L("        expect: "));	TestOut(CP54936_1);	INFO_PRINTF1(_L("\n"));

   441 	prevTime = User::FastCounter();

   442 	for (count=0; count<MaxCount; count++)

   443 		{

   444 		foreign1.Zero();

   445 		(*aConvertFromUnicode54936L)(foreign1, unicode1);

   446 		}

   447 	timeDiff = User::FastCounter() - prevTime;

   448 	fsSessionMicroSecs = timeDiff / (ticksPerMicroSec);

   449 	msg.Format(_L("                    %10.2lf us, "), fsSessionMicroSecs);

   450 	INFO_PRINTF1(_L("        result: "));	TestOut(foreign1);	INFO_PRINTF1(_L("\n"));

   451 	INFO_PRINTF1(msg);

   452 	error = foreign1.Compare(CP54936_1);

   453 	test(error==0);

   454 	foreign1.Zero();

   455 	INFO_PRINTF1(_L("\n"));

   457 //////////////////////////////////////////////////////////////////////////////

   458 //////////////////////////////////////////////////////////////////////////////

   459 	_LIT16(Uni_2, "\x0032\x20AC\xFFFD\x7FB1\x47BB\xD840\xDC00");

   460 	_LIT8(CP54936_2, "\x32\xA2\xE3\xC1\x7F\xC1\x7E\x82\x33\xED\x33\x95\x32\x82\x36");

   461 	const TDesC8& foreign2(CP54936_2);

   463 	// 4, 54936 -> unicode

   464 	// test result: 36 ms for 100000 iterations

   465 	INFO_PRINTF1(_L("54936 ---> unicode:\n"));

   466 	INFO_PRINTF1(_L("        source: "));	TestOut(foreign2);	INFO_PRINTF1(_L("\n"));

   467 	INFO_PRINTF1(_L("        expect: "));	TestOut(Uni_2);		INFO_PRINTF1(_L("\n"));

   468 	prevTime = User::FastCounter();

   469 	for (count=0; count<MaxCount; count++)

   470 		{

   471 		unicode2.Zero();

   472 		(*aConvertToUnicode54936L)(unicode2,foreign2);

   473 		}

   474 	timeDiff = User::FastCounter() - prevTime;

   475 	fsSessionMicroSecs = timeDiff / (ticksPerMicroSec);

   476 	msg.Format(_L("                    %10.2lf us, "), fsSessionMicroSecs);

   477 	INFO_PRINTF1(_L("        result: "));	TestOut(unicode2);	INFO_PRINTF1(_L("\n"));

   478 	INFO_PRINTF1(msg);

   479 	error = unicode2.Compare(Uni_2);

   480 	test(error==0);

   481 	unicode2.Zero();

   482 	INFO_PRINTF1(_L("\n"));

   484 	lib54936.Close();

   486 //	INFO_PRINTF1(_L("Press any key...\n"));

   487 //	test.Getch();

   488 	}

   490 /**

   491 @SYMTestCaseID          TI18N-FATCHARCONV-CIT-4001

   492 @SYMTestCaseDesc        Check GB18030 support

   493 @SYMTestPriority        High

   494 @SYMTestActions         1. Get one-byte Unicode codepoint

   495                         2. Convert to/from GB18030 to/from Unicode

   496                         3. Get two-byte Unicode codepoint

   497                         4. Convert to/from GB18030 to/from Unicode

   498                         5. Get four-byte Unicode codepoint

   499                         6. Convert to/from GB18030 to/from Unicode

   500 @SYMTestExpectedResults No side effect

   501 @SYMREQ                 REQ12067

   502 */

   503 void CT_CP54936::TestConversionL( const TDesC16& aUnicode, const TDesC8& a54936, TBool aZero1, TBool aZero2)

   504 {

   505     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-FATCHARSETCONV-CT-1778 "));

   506 	RLibrary lib;

   508 	const TUidType serverUid(KNullUid,KNullUid,KPluginUid);

   509 	// load the dll

   510 	TInt returnValue = lib.Load(KName,serverUid);

   511 	test(returnValue==0);

   513 	// get a pointer to the specified ordinal function and call it

   514 	TLibraryFunction function1 = lib.Lookup(1);

   515 	TLibraryFunction function2 = lib.Lookup(2);

   516 	TLibraryFunction function3 = lib.Lookup(3);

   518 	//cast the function pointer f to a function of type void with two arguments

   519 	typedef void (*TConvertFromUnicodeL)(TDes8&, const TDesC16&);

   520 	TConvertFromUnicodeL aConvertFromUnicodeL = reinterpret_cast <TConvertFromUnicodeL> (function1);

   522 	typedef void (*TConvertToUnicodeL)(TDes16&, const TDesC8&);

   523 	TConvertToUnicodeL aConvertToUnicodeL = reinterpret_cast <TConvertToUnicodeL> (function2);

   525 	//	testing conversion from Unicode

   526 	TBuf8<200> generated54936;

   527 	INFO_PRINTF1(_L("source: "));

   528 	TestOut(aUnicode);

   529 	INFO_PRINTF1(_L("\n"));

   530 	INFO_PRINTF1(_L("expect: "));

   531 	TestOut(a54936);

   532 	INFO_PRINTF1(_L("\n"));

   533 	(*aConvertFromUnicodeL)(generated54936, aUnicode);

   534 	INFO_PRINTF1(_L("result: "));

   535 	TestOut(generated54936);

   536 	INFO_PRINTF1(_L("\n"));

   537 	TInt error = generated54936.Compare(a54936);

   538 	if ( aZero1 )

   539 	{

   540 		test(error==0);

   541 	}

   542 	else

   543 	{

   544 		test(error!=0);

   545 	}

   547 	//	testing conversion to Unicode

   548 	TBuf16<200> generatedUnicode;

   549 	INFO_PRINTF1(_L("source: "));

   550 	TestOut(a54936);

   551 	INFO_PRINTF1(_L("\n"));

   552 	INFO_PRINTF1(_L("expect: "));

   553 	TestOut(aUnicode);

   554 	INFO_PRINTF1(_L("\n"));

   555 	(*aConvertToUnicodeL)(generatedUnicode,a54936);

   556 	INFO_PRINTF1(_L("result: "));

   557 	TestOut(generatedUnicode);

   558 	INFO_PRINTF1(_L("\n"));

   559 	error = generatedUnicode.Compare(aUnicode);

   560 	if ( aZero2 )

   561 	{

   562 		test(error==0);

   563 	}

   564 	else

   565 	{

   566 		test(error!=0);

   567 	}

   569 	lib.Close();

   570 }

   573 /**

   574 @SYMTestCaseID          TI18N-CHARCONV-CT-

   575 @SYMTestCaseDesc        Check GB18030 support

   576 @SYMTestPriority        High

   577 @SYMTestActions         1. Get one-byte Unicode codepoint

   578 						2. Convert to/from GB18030 to/from Unicode

   579 						3. Get two-byte Unicode codepoint

   580 						4. Convert to/from GB18030 to/from Unicode

   581 						5. Get four-byte Unicode codepoint

   582 						6. Convert to/from GB18030 to/from Unicode

   583 @SYMTestExpectedResults No side effect

   584 @SYMREQ                 REQ12067

   585 */

   586 void CT_CP54936::TestGbConversionL()

   587 {

   588 	//	TestL() function covers GB 1,2,4 bytes

   589 	//	one-byte

   590 	//	border 0x80

   591 	_LIT16(Uni_0, "\x0000");

   592 	_LIT8(CP54936_0, "\x00");

   593 	TestConversionL( Uni_0, CP54936_0 );

   595 	_LIT16(Uni_1, "\x0079");

   596 	_LIT8(CP54936_1, "\x79");

   597 	TestConversionL( Uni_1, CP54936_1 );

   599 	_LIT16(Uni_2, "\x0080");

   600 	_LIT8(CP54936_2, "\x81\x30\x81\x30");

   601 	TestConversionL( Uni_2, CP54936_2 );

   603 	_LIT16(Uni_3, "\x0081");

   604 	_LIT8(CP54936_3, "\x81\x30\x81\x31");

   605 	TestConversionL( Uni_3, CP54936_3 );

   607 	_LIT16(Uni_4, "\x00fe");

   608 	_LIT8(CP54936_4, "\x81\x30\x8B\x36");

   609 	TestConversionL( Uni_4, CP54936_4 );

   611 	_LIT16(Uni_5, "\x00ff");

   612 	_LIT8(CP54936_5, "\x81\x30\x8B\x37");

   613 	TestConversionL( Uni_5, CP54936_5 );

   615 	//	two-byte

   616 	_LIT16(Uni_6, "\x0100");

   617 	_LIT8(CP54936_6, "\x81\x30\x8B\x38");

   618 	TestConversionL( Uni_6, CP54936_6 );

   620 	_LIT16(Uni_7, "\x0101");

   621 	_LIT8(CP54936_7, "\xA8\xA1");

   622 	TestConversionL( Uni_7, CP54936_7 );

   624 	_LIT16(Uni_8, "\x0ffe");

   625 	_LIT8(CP54936_8, "\x81\x33\x83\x38");

   626 	TestConversionL( Uni_8, CP54936_8 );

   628 	_LIT16(Uni_9, "\x0fff");

   629 	_LIT8(CP54936_9, "\x81\x33\x83\x39");

   630 	TestConversionL( Uni_9, CP54936_9 );

   632 	_LIT16(Uni_10, "\x1000");

   633 	_LIT8(CP54936_10, "\x81\x33\x84\x30");

   634 	TestConversionL( Uni_10, CP54936_10 );

   636 	_LIT16(Uni_11, "\x1001");

   637 	_LIT8(CP54936_11, "\x81\x33\x84\x31");

   638 	TestConversionL( Uni_11, CP54936_11 );

   640 	_LIT16(Uni_12, "\xfffe");

   641 	_LIT8(CP54936_12, "\x84\x31\xA4\x38");

   642 	TestConversionL( Uni_12, CP54936_12 );

   644 	_LIT16(Uni_13, "\xffff");

   645 	_LIT8(CP54936_13, "\x84\x31\xA4\x39");

   646 	TestConversionL( Uni_13, CP54936_13 );

   648 	//	four-byte

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

   650 	_LIT8(CP54936_14, "\x95\x32\x82\x36");

   651 	TestConversionL( Uni_14, CP54936_14 );

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

   654 	_LIT8(CP54936_15, "\x95\x32\x82\x37");

   655 	TestConversionL( Uni_15, CP54936_15 );

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

   658 	_LIT8(CP54936_16, "\x9a\x34\x84\x30");

   659 	TestConversionL( Uni_16, CP54936_16 );

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

   662 	_LIT8(CP54936_17, "\x9a\x34\x84\x31");

   663 	TestConversionL( Uni_17, CP54936_17 );

   665 	//	4-byte gb

   666 	_LIT16(Uni_18, "\xd840\xddad");

   667 	_LIT8(CP54936_18, "\x95\x32\xAD\x35");

   668 	TestConversionL( Uni_18, CP54936_18 );

   670 	_LIT16(Uni_19, "\xd801\xdd00");

   671 	_LIT8(CP54936_19, "\x90\x31\x83\x30");

   672 	TestConversionL( Uni_19, CP54936_19 );

   673 }

   676 /**

   677 @SYMTestCaseID          TI18N-CHARCONV-CT-

   678 @SYMTestCaseDesc        Test FAT short name legal character

   679 @SYMTestPriority        High

   680 @SYMTestActions         1. Get one-byte Unicode codepoint

   681 						2. Check if it's legal short name character

   682 						3. Get two-byte Unicode codepoint

   683 						4. Check if it's legal short name character

   684 						5. Get four-byte Unicode codepoint

   685 						6. Check if it's legal short name character

   686 @SYMTestExpectedResults No side effect

   687 @SYMREQ                 REQ12067

   688 */

   689 void CT_CP54936::TestShortNameCharacterL()

   690 {

   691     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-FATCHARSETCONV-CT-1778 "));

   692 	RLibrary lib;

   694 	const TUidType serverUid(KNullUid,KNullUid,KPluginUid);

   695 	// 	load the dll

   696 	TInt returnValue = lib.Load(KName,serverUid);

   697 	test(returnValue==0);

   699 	// 	get a pointer to the specified ordinal function and call it

   700 	TLibraryFunction function1 = lib.Lookup(1);

   701 	TLibraryFunction function2 = lib.Lookup(2);

   702 	TLibraryFunction function3 = lib.Lookup(3);

   704 	typedef TBool (*TIsLegalShortNameCharacter)(TUint);

   705 	TIsLegalShortNameCharacter aIsLegalShortNameCharacter = reinterpret_cast <TIsLegalShortNameCharacter> (function3);

   707 	//	testing for legal short name character

   708 	//	one-byte unicode

   709 	//	0x20 is space

   710 	TInt result = (*aIsLegalShortNameCharacter)(0x0019);

   711 	test(result==0);

   713 	result = (*aIsLegalShortNameCharacter)(0x0020);

   714 	test(result==0);

   716 	result = (*aIsLegalShortNameCharacter)(0x0021);

   717 	test(result==1);

   719 	result = (*aIsLegalShortNameCharacter)(0x005F);

   720 	test(result==1);

   722 	//	0x80 is ascii border

   723 	result = (*aIsLegalShortNameCharacter)(0x0079);

   724 	test(result==1);

   726 	result = (*aIsLegalShortNameCharacter)(0x0080);

   727 	test(result==1);

   729 	result = (*aIsLegalShortNameCharacter)(0x0081);

   730 	test(result==1);

   732 	//	testing for illegal character

   733 	result = (*aIsLegalShortNameCharacter)(0x003F);

   734 	test(result==0);

   736 	result = (*aIsLegalShortNameCharacter)(0x22);

   737 	test(result==0);

   739 	result = (*aIsLegalShortNameCharacter)(0x2A);

   740 	test(result==0);

   742 	result = (*aIsLegalShortNameCharacter)(0x2B);

   743 	test(result==0);

   745 	result = (*aIsLegalShortNameCharacter)(0x2C);

   746 	test(result==0);

   748 	result = (*aIsLegalShortNameCharacter)(0x2F);

   749 	test(result==0);

   751 	result = (*aIsLegalShortNameCharacter)(0x3A);

   752 	test(result==0);

   754 	result = (*aIsLegalShortNameCharacter)(0x3B);

   755 	test(result==0);

   757 	result = (*aIsLegalShortNameCharacter)(0x3C);

   758 	test(result==0);

   760 	result = (*aIsLegalShortNameCharacter)(0x3D);

   761 	test(result==0);

   763 	result = (*aIsLegalShortNameCharacter)(0x3E);

   764 	test(result==0);

   766 	result = (*aIsLegalShortNameCharacter)(0x5B);

   767 	test(result==0);

   769 	result = (*aIsLegalShortNameCharacter)(0x5C);

   770 	test(result==0);

   772 	result = (*aIsLegalShortNameCharacter)(0x5D);

   773 	test(result==0);

   775 	result = (*aIsLegalShortNameCharacter)(0x7C);

   776 	test(result==0);

   778 	//	two-byte unicode

   779 	result = (*aIsLegalShortNameCharacter)(0x1000);

   780 	test(result==1);

   782 	result = (*aIsLegalShortNameCharacter)(0x1001);

   783 	test(result==1);

   785 	result = (*aIsLegalShortNameCharacter)(0x2999); //testing for non-existent character

   786 	test(result==1);

   788 	result = (*aIsLegalShortNameCharacter)(0x4E02); //testing for a double byte character

   789 	test(result==1);

   791 	result = (*aIsLegalShortNameCharacter)(0xfffe);

   792 	test(result==1);

   794 	result = (*aIsLegalShortNameCharacter)(0xffff);

   795 	test(result==1);

   797 	result = (*aIsLegalShortNameCharacter)(0xd7ff);

   798 	test(result==1);

   800 	//	surrogate part

   801 	result = (*aIsLegalShortNameCharacter)(0xd800);

   802 	test(result==0);

   804 	result = (*aIsLegalShortNameCharacter)(0xdfff);

   805 	test(result==0);

   807 	result = (*aIsLegalShortNameCharacter)(0xe000);

   808 	test(result==1);

   810 	//	four-byte unicode

   811 	result = (*aIsLegalShortNameCharacter)(0x10000);

   812 	test(result==1);

   814 	result = (*aIsLegalShortNameCharacter)(0x10001);

   815 	test(result==1);

   817 	result = (*aIsLegalShortNameCharacter)(0x10fffe);

   818 	test(result==1);

   820 	result = (*aIsLegalShortNameCharacter)(0x10ffff);

   821 	test(result==1);

   823 	result = (*aIsLegalShortNameCharacter)(0x110000);

   824 	test(result==0);

   826 	lib.Close();

   827 }

   830 CT_CP54936::CT_CP54936()

   831     {

   832     SetTestStepName(KTestStep_T_CP54936);

   833     }

   836 TVerdict CT_CP54936::doTestStepL()

   837     {

   838     SetTestStepResult(EFail);

   840     __UHEAP_MARK;

   842     TRAPD(error1, TestGbConversionL());

   843     TRAPD(error2, TestShortNameCharacterL());

   844     TRAPD(error3, TestL());

   845     TRAPD(error4, TestINC090073L());

   846     TRAPD(error5, OOMTestL());

   847     TRAPD(error6, PerformanceTest1L());

   848     TRAPD(error7, PerformanceTest2L());

   850     __UHEAP_MARKEND;

   852     if(error1 == KErrNone && error2 == KErrNone && error3 == KErrNone

   853             && error4 == KErrNone && error5 == KErrNone

   854             && error6 == KErrNone && error7 == KErrNone)

   855         {

   856         SetTestStepResult(EPass);

   857         }

   859     return TestStepResult();

   860     }

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