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

     1 /*

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

    20 #include <e32des8.h>

    22 #define test(cond)                                          \

    23     {                                                       \

    24     TBool __bb = (cond);                                    \

    25     TEST(__bb);                                             \

    26     if (!__bb)                                              \

    27         {                                                   \

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

    29         User::Leave(1);                                     \

    30         }                                                   \

    31     }

    34 _LIT16(Uni_1, "\x0053\x3125\x3122\xAAAA\x9673\x2593\xFA0C\x3000");

    35 _LIT8(CP950_1, "\x53\xA3\xB6\xA3\xB3\x5F\xB3\xAF\xF9\xFE\xC9\x4A\xA1\x40");

    36 _LIT16(Uni_2, "\x0032\xFFFD\xFE3E\xFFFD\xFFFD");

    37 _LIT8(CP950_2, "\x32\x80\xA1\x70\xC1\x7F\xA7");

    39 _LIT(KName,"CP950");

    40 const TUid KPluginUid={0x10206A8C};

    43 // Used for supressing warning in OOM tests

    44 #define __UNUSED_VAR(var) var = var

    46 //

    47 /**

    48 @SYMTestCaseID          SYSLIB-FATCHARSETCONV-CT-1776

    49 @SYMTestCaseDesc	    Tests API behaviours of UnicodeConv class

    50 @SYMTestPriority 	    High

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

    52 @SYMTestExpectedResults Test must not fail

    53 */

    54 void CT_CP950::TestL()

    55 	{

    56     INFO_PRINTF1(_L("@SYMTestCaseID:SYSLIB-FATCHARSETCONV-CT-1776"));

    57 	RLibrary lib;

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

    60 	// load the dll

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

    62 	test(returnValue==0);

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

    65 	TLibraryFunction function1 = lib.Lookup(1);

    66 	TLibraryFunction function2 = lib.Lookup(2);

    67 	TLibraryFunction function3 = lib.Lookup(3);

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

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

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

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

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

    76 	typedef TBool (*TIsLegalShortNameCharacter)(TUint);

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

    79 	TBuf8<20> foreign1;

    80 	TBuf16<20> unicode2;

    82 	const TDesC16& unicode1(Uni_1);

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

    84 	TInt error = foreign1.Compare(CP950_1);

    86 	test(error==0);

    87 	foreign1.Zero();

    89 	const TDesC8& foreign2(CP950_2);

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

    91 	error = unicode2.Compare(Uni_2);

    92 	test(error==0);

    93 	unicode2.Zero();

    96 	//testing for legal short name character

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

    98 	test(result==1);

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

   100 	test(result==0);

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

   102 	test(result==0);

   103 	result = (*aIsLegalShortNameCharacter)(0x3000); //testing for a double byte character

   104 	test(result==1);

   106 	lib.Close();

   107 	}

   109 // test code for INC080460: FATCharsetConv panics - stops china build booting

   110 void CT_CP950::TestINC080460L()

   111 	{

   112 	RLibrary lib;

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

   115 	// load the dll

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

   117 	test(returnValue==0);

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

   120 	TLibraryFunction function1 = lib.Lookup(1);

   121 	TLibraryFunction function2 = lib.Lookup(2);

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

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

   125 	TConvertFromUnicodeL ConvertFromUnicodeL = reinterpret_cast <TConvertFromUnicodeL> (function1);

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

   128 	TConvertToUnicodeL ConvertToUnicodeL = reinterpret_cast <TConvertToUnicodeL> (function2);

   130 	// the problem in this defect is when the foreign buffer is not big enough the code panics

   131 	// the solution is for the code to leave

   133 	// the foreign buffer is 11 (8+3) and there are 17 unicode characters

   134 	TBuf8<11> foreign;

   135 	_LIT16(longUnicode, "\x0053\x3125\x3122\xAAAA\x0053\x3125\x3122\xAAAA\x0053\x3125\x3122\xAAAA\x0053\x3125\x3122\xAAAA");

   136 	const TDesC16& testUnicode1(longUnicode);

   137 	TInt error = KErrNone;

   139 	// ConvertFromUnicodeL - check that this call leaves

   140 	foreign.Zero();

   141 	TRAP( error, ConvertFromUnicodeL(foreign, testUnicode1)); 	//testing conversion from Unicode

   142 	test(error == KErrOverflow );

   144 	// ConvertFromUnicodeL - test 1 character to long leaves

   145 	_LIT16(longUnicode2, "FilenameEx\x3122");

   146 	const TDesC16& testUnicode2(longUnicode2);

   147 	foreign.Zero();

   148 	error = KErrNone;

   149 	TRAP( error, ConvertFromUnicodeL(foreign, testUnicode2)); 	//testing conversion from Unicode

   150 	test(error == KErrOverflow );

   152 	// ConvertFromUnicodeL - test 11 character does not leave

   153 	_LIT16(longUnicode3, "FilenameExt");

   154 	const TDesC16& testUnicode3(longUnicode3);

   155 	foreign.Zero();

   156 	error = KErrNone;

   157 	TRAP( error, ConvertFromUnicodeL(foreign, testUnicode3)); 	//testing conversion from Unicode

   158 	test(error == KErrNone );

   160 	// check ConvertToUnicodeL leaves when the buffer is too small

   161 	TBuf16<6> unicodeBuffer;

   162 	_LIT8(sampletext, "this is far to big to fit");

   163 	const TDesC8& sample(sampletext);

   165 	unicodeBuffer.Zero();

   166 	error = KErrNone;

   167 	TRAP( error,ConvertToUnicodeL(unicodeBuffer,sample)); 	//testing conversion to Unicode

   168 	test(error==KErrOverflow);

   170 	// test 6 characters does NOT leave

   171 	_LIT8( chars6, "abcdef");

   172 	const TDesC8& sample6(chars6);

   173 	unicodeBuffer.Zero();

   174 	error = KErrNone;

   175 	TRAP( error,ConvertToUnicodeL(unicodeBuffer,sample6)); 	//testing conversion to Unicode

   176 	test(error==KErrNone);

   178 	// test 7 characters does leave

   179 	_LIT8( chars7, "abcdefg");

   180 	const TDesC8& sample7(chars7);

   181 	unicodeBuffer.Zero();

   182 	error = KErrNone;

   183 	TRAP( error,ConvertToUnicodeL(unicodeBuffer,sample7)); 	//testing conversion to Unicode

   184 	test(error==KErrOverflow);

   186 	// test when 7 foreign characters fits in 5 unicode it does NOT leave

   187 	_LIT8( CP950_sample, "\x32\x80\xA1\x70\xC1\x7F\xA7");

   188 	const TDesC8& sample7to5(CP950_sample);

   189 	unicodeBuffer.Zero();

   190 	error = KErrNone;

   191 	TRAP( error,ConvertToUnicodeL(unicodeBuffer,sample7to5)); 	//testing conversion to Unicode

   192 	test(error==KErrNone);

   194 	lib.Close();

   195 	}

   198 /**

   199 @SYMTestCaseID          SYSLIB-FATCHARSETCONV-CT-1847-0003

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

   201 @SYMTestPriority 	    High

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

   203 @SYMTestExpectedResults Test must not fail

   204 */

   205 void CT_CP950::TestINC090073L()

   206 	{

   207     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-FATCHARSETCONV-CT-1847-0003 "));

   208  	_LIT16(unicode, "\x7C91\x8026\x8160\x7633\x6DFC\x715C\x6600\x9785\x86D8\x7A37\x61A9\x80B1\x86A3\x89E5\x80F2\x9B48\x6C19\x7B71\x946B\x6B46\x6615");

   209 	_LIT8(CP950Code, "\xD3\x4A\xBD\xA2\xDF\x73\xEA\x6F\xD9\xE7\xB7\xD4\xA9\xFB\xBB\xDF\xDB\xB1\xBD\x5E\xBE\xCD\xAA\xD0\xB0\x47\xDF\xFD\xD3\x6A\xEF\x69\xCB\x49\xDF\x4E\xF8\xCA\xDD\xF5\xA9\xFD");

   211 	RLibrary lib;

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

   214 	// load the dll

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

   216 	test(returnValue==0);

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

   219 	TLibraryFunction function1 = lib.Lookup(1);

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

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

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

   225 	TBuf8<50> foreign1;

   227 	foreign1.Zero();

   228 	const TDesC16& unicode1(unicode);

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

   230 	test(err==0);

   231 	TInt error = foreign1.Compare(CP950Code);

   232 	test(error==0);

   233 	foreign1.Zero();

   235 	lib.Close();

   236 	}

   238 void CT_CP950::OOMTestL()

   239 	{

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

   241 	TInt err, tryCount = 0;

   242 	do

   243 		{

   244 			__UHEAP_MARK;

   245   		// find out the number of open handles

   246 		TInt startProcessHandleCount;

   247 		TInt startThreadHandleCount;

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

   250 			// Setting Heap failure for OOM test

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

   253 		TRAP(err,TestL());

   255 		__UHEAP_SETFAIL(RHeap::ENone, 0);

   257 		// check that no handles have leaked

   258 		TInt endProcessHandleCount;

   259 		TInt endThreadHandleCount;

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

   262 		test(startProcessHandleCount == endProcessHandleCount);

   263 		test(startThreadHandleCount  == endThreadHandleCount);

   265 		__UHEAP_MARKEND;

   266 		}while (err == KErrNoMemory);

   268 	test(err == KErrNone);

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

   270 	}

   273 CT_CP950::CT_CP950()

   274     {

   275     SetTestStepName(KTestStep_T_CP950);

   276     }

   279 TVerdict CT_CP950::doTestStepL()

   280     {

   281     SetTestStepResult(EFail);

   283     __UHEAP_MARK;

   285     TRAPD(error1, TestL());

   286     TRAPD(error2, TestINC090073L());

   287     TRAPD(error3, TestINC080460L());

   288     TRAPD(error4, OOMTestL());

   290     __UHEAP_MARKEND;

   292     if(error1 == KErrNone && error2 == KErrNone && error3 == KErrNone && error4 == KErrNone)

   293         {

   294         SetTestStepResult(EPass);

   295         }

   297     return TestStepResult();

   298     }

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