1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Implementation of test CWSPDecodeTest

    15 // 

    16 //

    17 

    18 #include "cwspdecodetest.h"

    19 #include <wspdummyconstants.h>

    20 

    21 

    22 

    23 CWSPDecodeTest* CWSPDecodeTest::NewLC(CIpuTestHarness* aTestHarness)

    24 	{

    25 	CWSPDecodeTest* self = new(ELeave)CWSPDecodeTest(aTestHarness);

    26 	CleanupStack::PushL(self);

    27 	return self;

    28 	}

    29 

    30 

    31 CWSPDecodeTest::CWSPDecodeTest(CIpuTestHarness* aTestHarness):

    32 	iTestHarness(aTestHarness)

    33 	{}

    34 

    35 CWSPDecodeTest::~CWSPDecodeTest()

    36 	{}

    37 

    38 void CWSPDecodeTest::DoTestsL()

    39 	{

    40 	VarTypesTestL();

    41 	LengthValsTestL();

    42 	StringTestL();

    43 	TokensTestL();

    44 	IntegersTestL();

    45 	LongIntTestL();

    46 	UintVarsTestL();

    47 	VersionTestL();

    48 	DateTestL();

    49 	SegmenterTestL();

    50 	}

    51 

    52 

    53 //* VarTypes */

    54 

    55 TBool CWSPDecodeTest::VarType(TPtrC8 aBuf, TWspPrimitiveDecoder::TWspHeaderType aShouldBeType)

    56 	{

    57 	TWspPrimitiveDecoder dec(aBuf);

    58 	TWspPrimitiveDecoder::TWspHeaderType type=dec.VarType();

    59 	

    60 	TBool bSuccess  = EFalse;

    61 	if (type == aShouldBeType)

    62 		bSuccess = ETrue;

    63 

    64 	TBuf8<25> typeStr;

    65 	switch (aShouldBeType)

    66 	{

    67 	case TWspPrimitiveDecoder::ENotSet:

    68 		typeStr.Copy(_L("ENotSet"));

    69 		break;

    70 	case TWspPrimitiveDecoder::ELengthVal:

    71 		typeStr.Copy(_L("ELengthVal"));

    72 		break;

    73 	case TWspPrimitiveDecoder::EQuotedString:

    74 		typeStr.Copy(_L("EQuotedString"));

    75 		break;	

    76 	case TWspPrimitiveDecoder::EString:

    77 		typeStr.Copy(_L("EString"));

    78 		break;

    79 	case TWspPrimitiveDecoder::E7BitVal:

    80 		typeStr.Copy(_L("E7BitVal"));

    81 		break;

    82 	}

    83 	return bSuccess;

    84 	}

    85 

    86 

    87 void CWSPDecodeTest::VarTypesTestL()

    88 	{

    89 	_LIT(KTestText, "WSP Decode: VarTypes");

    90 	iTestHarness->StartTestL(KTestText);

    91 	TRAPD(error, TestVarTypesL());

    92 	iTestHarness->EndTest(error);

    93 	User::LeaveIfError(error);

    94 	}

    95 

    96 void CWSPDecodeTest::TestVarTypesL()

    97 	{

    98 	const TUint8 KToken[] = {0x81};

    99 	const TUint8 KString1[] = {'a', 'b', 'c', 0x00};

   100 	const TUint8 KString2[] = {0x33};

   101 	const TUint8 KLen0[] = {0x00};

   102 	const TUint8 KLen1[] = {0x01};

   103 	const TUint8 KLen2[] = {0x1F};

   104 		

   105 	TBuf8<255> buf;

   106 	buf.Copy(KToken, sizeof(KToken));

   107 	if (!VarType(buf, TWspPrimitiveDecoder::E7BitVal))

   108 		User::Leave(KErrGeneral);

   109 

   110 	buf.Copy(KString1, sizeof(KString1));

   111 	if (!VarType(buf, TWspPrimitiveDecoder::EString))

   112 		User::Leave(KErrGeneral);

   113 

   114 	buf.Copy(KString2, sizeof(KString2));

   115 	if (!VarType(buf, TWspPrimitiveDecoder::EString))

   116 		User::Leave(KErrGeneral);

   117 

   118 	buf.Copy(KLen0, sizeof(KLen0));

   119 	if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))

   120 		User::Leave(KErrGeneral);

   121 

   122 	buf.Copy(KLen1, sizeof(KLen1));

   123 	if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))

   124 		User::Leave(KErrGeneral);

   125 

   126 	buf.Copy(KLen2, sizeof(KLen2));

   127 	if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))

   128 		User::Leave(KErrGeneral);

   129 	}

   130 

   131 

   132 

   133 

   134 //* LenVal */

   135 

   136 TBool CWSPDecodeTest::LenVal(TPtrC8 aBuf, TInt aShouldBeVal)

   137 	{

   138 	TBool success  = EFalse;

   139 	TWspPrimitiveDecoder dec(aBuf);	

   140 	TInt len;

   141 	success = dec.LengthVal(len);

   142 	if (success == KErrCorrupt)

   143 		return ETrue;

   144 

   145 	return len == aShouldBeVal && !(success < KErrNone);

   146 	}

   147 

   148 

   149 void CWSPDecodeTest::LengthValsTestL()

   150 	{

   151 	_LIT(KTestText, "WSP Decode: LengthVals");

   152 	iTestHarness->StartTestL(KTestText);

   153 	TRAPD(error, TestLengthValsL());

   154 	iTestHarness->EndTest(error);

   155 	User::LeaveIfError(error);

   156 	}

   157 

   158 void CWSPDecodeTest::TestLengthValsL()

   159 	{

   160 	const TUint8 KLen0[] = {0x00};

   161 	const TUint8 KLen1[] = {0x01};

   162 	const TUint8 KLen26[] = {0x1A};

   163 	const TUint8 KLenUintVAR17680[] = {0x1F, 0x81,0x8A,0x10};

   164 	const TUint8 KLenUintVARCorrupt[] = {0x1F, 0x81,0x8A,0x80};

   165 		

   166 	

   167 	TBuf8<255> buf;

   168 	buf.Copy(KLen0, sizeof(KLen0));

   169 	if (!LenVal(buf, 0))

   170 		User::Leave(KErrGeneral);

   171 

   172 	buf.Copy(KLen1, sizeof(KLen1));

   173 	if (!LenVal(buf, 1))

   174 		User::Leave(KErrGeneral);

   175 

   176 	buf.Copy(KLen26, sizeof(KLen26));

   177 	if (!LenVal(buf, 0x1A))

   178 		User::Leave(KErrGeneral);

   179 

   180 	buf.Copy(KLenUintVAR17680, sizeof(KLenUintVAR17680));

   181 	if (!LenVal(buf, 17680))

   182 		User::Leave(KErrGeneral);

   183 	

   184 	buf.Copy(KLenUintVARCorrupt, sizeof(KLenUintVARCorrupt));

   185 	if (!LenVal(buf, -1))

   186 		User::Leave(KErrGeneral);

   187 

   188 	}

   189 

   190 

   191 

   192 //* String */

   193 

   194 TBool CWSPDecodeTest::String(TPtrC8 aBuf, TPtrC8 aShouldBe, TInt /*aErr*/)

   195 	{

   196 	TBool success  = EFalse;

   197 	TWspPrimitiveDecoder dec(aBuf);

   198 	

   199 	TPtrC8 str;

   200 	success = dec.String(str);

   201 	if (success < KErrNone)

   202 		return success;

   203 

   204 

   205 	if (str != aShouldBe)

   206 		success = EFalse;

   207 

   208 	// Copy to 16 bits

   209 	return success;

   210 	}

   211 

   212 

   213 

   214 void CWSPDecodeTest::StringTestL()

   215 	{

   216 	_LIT(KTestText, "WSP Decode: String");

   217 	iTestHarness->StartTestL(KTestText);

   218 	TRAPD(error, TestStringL());

   219 	iTestHarness->EndTest(error);

   220 	User::LeaveIfError(error);

   221 	}

   222 

   223 

   224 void CWSPDecodeTest::TestStringL()

   225 	{

   226 	const TUint8 KStringHello[] = {'H','e','l','l','o',0x00};

   227 	const TUint8 KStringEmpty[] = {0x00};

   228 	const TUint8 KStringNotAString[] = {0x1A};

   229 	const TUint8 KStringCorruptNoZero[] = {'H','e','l','l','o'};

   230 	const TUint8 KStringbye[] = {'b','y','e',0x00};

   231 		

   232 	TBuf8<255> buf;

   233 	

   234 	buf.Copy(KStringHello, sizeof(KStringHello));

   235 	if (!String(buf, _L8("Hello")))

   236 		User::Leave(KErrGeneral);

   237 

   238 	buf.Copy(KStringEmpty, sizeof(KStringEmpty));

   239 	if (!String(buf, _L8(""),KErrCorrupt))

   240 		User::Leave(KErrGeneral);

   241 

   242 	buf.Copy(KStringNotAString, sizeof(KStringNotAString));

   243 	if (!String(buf, _L8(""), KErrCorrupt))

   244 		User::Leave(KErrGeneral);

   245 

   246 	buf.Copy(KStringCorruptNoZero, sizeof(KStringCorruptNoZero));

   247 	if (!String(buf, _L8(""), KErrCorrupt))

   248 		User::Leave(KErrGeneral);

   249 	

   250 	buf.Copy(KStringbye, sizeof(KStringbye));

   251 	if (!String(buf, _L8("bye")))

   252 		User::Leave(KErrGeneral);

   253 	}

   254 

   255 //* Tokens */

   256 

   257 TBool CWSPDecodeTest::Token(TPtrC8 aBuf, TUint8 aShouldBe, TInt aErr)

   258 	{

   259 	TInt success;

   260 	TWspPrimitiveDecoder dec(aBuf);

   261 	

   262 	TUint8 val;

   263 	success = dec.Val7Bit(val);

   264 	if (success < KErrNone && success == aErr)

   265 		return ETrue;

   266 

   267 	return val == aShouldBe;

   268 	}

   269 

   270 void CWSPDecodeTest::TokensTestL()

   271 	{

   272 	_LIT(KTestText, "WSP Decode: Tokens");

   273 	iTestHarness->StartTestL(KTestText);

   274 	TRAPD(error, TestTokensL());

   275 	iTestHarness->EndTest(error);

   276 	User::LeaveIfError(error);

   277 	}

   278 

   279 

   280 void CWSPDecodeTest::TestTokensL()

   281 	{

   282 	const TUint8 KToken0[] = {0x80};

   283 	const TUint8 KToken1[] = {0x81};

   284 	const TUint8 KToken1A[] = {0x9A};

   285 	const TUint8 KToken38[] = {0xB8};

   286 	const TUint8 KTokenCorruptLen[] = {0x01};

   287 	TBuf8<255> buf;

   288 	

   289 	buf.Copy(KToken0, sizeof(KToken0));

   290 	if (!Token(buf, 0))

   291 		User::Leave(KErrGeneral);

   292 

   293 	buf.Copy(KToken1, sizeof(KToken1));

   294 	if (!Token(buf, 1))

   295 		User::Leave(KErrGeneral);

   296 

   297 	buf.Copy(KToken1A, sizeof(KToken1A));

   298 	if (!Token(buf, 0x1A))

   299 		User::Leave(KErrGeneral);

   300 

   301 	buf.Copy(KToken38, sizeof(KToken38));

   302 	if (!Token(buf, 0x38))

   303 		User::Leave(KErrGeneral);

   304 	

   305 	buf.Copy(KTokenCorruptLen, sizeof(KTokenCorruptLen));

   306 	if (!Token(buf, 1))

   307 		User::Leave(KErrGeneral);

   308 	}

   309 

   310 

   311 //* Integers */

   312 

   313 TBool CWSPDecodeTest::Integer(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)

   314 	{

   315 	TInt success;

   316 	TWspPrimitiveDecoder dec(aBuf);

   317 	TUint32 val;

   318 	success = dec.Integer(val);

   319 	if (success < KErrNone && success == aErr)

   320 		return success;

   321 	return val == aShouldBe;

   322 	}

   323 

   324 

   325 

   326 void CWSPDecodeTest::IntegersTestL()

   327 	{

   328 	_LIT(KTestText, "WSP Decode: Integers");

   329 	iTestHarness->StartTestL(KTestText);

   330 	TRAPD(error, TestIntegersL());

   331 	iTestHarness->EndTest(error);

   332 	User::LeaveIfError(error);

   333 	}

   334 

   335 

   336 void CWSPDecodeTest::TestIntegersL()

   337 	{

   338 	const TUint8 KInt0[] = {0x80};

   339 	const TUint8 KInt1[] = {0x81};

   340 	const TUint8 KIntA[] = {0x8A};

   341 	const TUint8 KInt38[] = {0xB8};

   342 	const TUint8 KIntLong4321[] = {0x02, 0x43,0x21};

   343 	const TUint8 KIntLongABCDEF[] = {0x03, 0xAB,0xCD,0xEF};

   344 	const TUint8 KIntCorrupt[] = {0x01};

   345 	TBuf8<255> buf;

   346 	

   347 	buf.Copy(KInt0, sizeof(KInt0));

   348 	if (!Integer(buf, 0))

   349 		User::Leave(KErrGeneral);

   350 

   351 	buf.Copy(KInt1, sizeof(KIntA));

   352 	if (!Integer(buf, 1))

   353 		User::Leave(KErrGeneral);

   354 

   355 	buf.Copy(KIntA, sizeof(KIntA));

   356 	if (!Integer(buf, 0x0A))

   357 		User::Leave(KErrGeneral);

   358 

   359 	buf.Copy(KInt38, sizeof(KInt38));

   360 	if (!Integer(buf, 0x38))

   361 		User::Leave(KErrGeneral);

   362 	

   363 	buf.Copy(KIntLong4321, sizeof(KIntLong4321));

   364 	if (!Integer(buf, 0x4321))

   365 		User::Leave(KErrGeneral);

   366 

   367 	buf.Copy(KIntLongABCDEF, sizeof(KIntLongABCDEF));

   368 	if (!Integer(buf, 0xABCDEF))

   369 		User::Leave(KErrGeneral);

   370 

   371 	buf.Copy(KIntCorrupt, sizeof(KIntCorrupt));

   372 	if (!Integer(buf,0, KErrCorrupt))

   373 		User::Leave(KErrGeneral);

   374 	}

   375 

   376 //* LongInt */

   377 

   378 TBool CWSPDecodeTest::LongInt(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)

   379 	{

   380 	TInt success;

   381 	TWspPrimitiveDecoder dec(aBuf);

   382 	

   383 	TUint32 val;

   384 	success = dec.LongInt(val);

   385 	if (success < KErrNone && success == aErr)

   386 		return ETrue;

   387 	return val == aShouldBe;

   388 	}

   389 

   390 

   391 

   392 void CWSPDecodeTest::LongIntTestL()

   393 	{

   394 	_LIT(KTestText, "WSP Decode: LongInt");

   395 	iTestHarness->StartTestL(KTestText);

   396 	TRAPD(error, TestLongIntL());

   397 	iTestHarness->EndTest(error);

   398 	User::LeaveIfError(error);

   399 	}

   400 

   401 

   402 

   403 void CWSPDecodeTest::TestLongIntL()

   404 	{

   405 	const TUint8 KIntLong0[] = {0x01, 0x00};

   406 	const TUint8 KIntLong4321[] = {0x02, 0x43,0x21};

   407 	const TUint8 KIntLongABCDEF[] = {0x03, 0xAB,0xCD,0xEF};

   408 	const TUint8 KIntLongABCDEF112233[] = {0x06, 0xAB,0xCD,0xEF, 0x11,0x22,0x33};

   409 	const TUint8 KIntTooLong110009ABCDEF112233[] = {0x0A, 0x11,0x00, 0x09, 0xAB,0xCD,0xEF, 0x11,0x22,0x33};

   410 	const TUint8 KIntCorrupt[] = {0x01};

   411 	TBuf8<255> buf;

   412 	buf.Copy(KIntLong0, sizeof(KIntLong0));

   413 	if (!LongInt(buf, 0))

   414 		User::Leave(KErrGeneral);

   415 

   416 	buf.Copy(KIntLong4321, sizeof(KIntLong4321));

   417 	if (!LongInt(buf, 0x4321))

   418 		User::Leave(KErrGeneral);

   419 

   420 	buf.Copy(KIntLongABCDEF, sizeof(KIntLongABCDEF));

   421 	if (!LongInt(buf, 0xABCDEF))

   422 		User::Leave(KErrGeneral);

   423 

   424 	buf.Copy(KIntLongABCDEF112233, sizeof(KIntLongABCDEF112233));

   425 	if (!LongInt(buf, 0xEF112233))

   426 		User::Leave(KErrGeneral);

   427 	

   428 	buf.Copy(KIntTooLong110009ABCDEF112233, sizeof(KIntTooLong110009ABCDEF112233));

   429 	if (!LongInt(buf, 0x09ABCDEF, KErrCorrupt))

   430 		User::Leave(KErrGeneral);

   431 

   432 	buf.Copy(KIntCorrupt, sizeof(KIntCorrupt));

   433 	if (!LongInt(buf, 0, KErrCorrupt))

   434 		User::Leave(KErrGeneral);

   435 	}

   436 

   437 

   438 

   439 //* UintVar */

   440 

   441 TBool CWSPDecodeTest::UintVar(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)

   442 	{

   443 	TInt success;

   444 	TWspPrimitiveDecoder dec(aBuf);

   445 	TUint32 val;

   446 	success = dec.UintVar(val);

   447 	if (success < KErrNone && success == aErr)

   448 		return ETrue;

   449 	return val == aShouldBe;

   450 	}

   451 

   452 

   453 void CWSPDecodeTest::UintVarsTestL()

   454 	{

   455 	_LIT(KTestText, "WSP Decode: UintVars");

   456 	iTestHarness->StartTestL(KTestText);

   457 	TRAPD(error, TestUintVarsL());

   458 	iTestHarness->EndTest(error);

   459 	User::LeaveIfError(error);

   460 	}

   461 

   462 

   463 void CWSPDecodeTest::TestUintVarsL()

   464 	{

   465 	const TUint8 KUint0[] = {0x00};

   466 	const TUint8 KUint1[] = {0x01};

   467 	const TUint8 KUintA[] = {0x80,0x0A};

   468 	const TUint8 KUintFA[] = {0x81,0x7A};

   469 	const TUint8 KLenUintVAR4510[] = {0x81, 0x8A, 0x10};

   470 	const TUint8 KLenUintVARCorrupt[] = {0x8F, 0x81,0x8A,0x80,0x88};

   471 	const TUint8 KIntLongACorrupt[] = {0xF3, 0xAB,0xCD,0xEF};

   472 		

   473 	

   474 	TBuf8<255> buf;

   475 	

   476 	buf.Copy(KUint0, sizeof(KUint0));

   477 	if (!UintVar(buf, 0))

   478 		User::Leave(KErrGeneral);

   479 

   480 	buf.Copy(KUint1, sizeof(KUint1));

   481 	if (!UintVar(buf, 1))

   482 		User::Leave(KErrGeneral);

   483 

   484 	buf.Copy(KUintA, sizeof(KUintA));

   485 	if (!UintVar(buf, 0x0A))

   486 		User::Leave(KErrGeneral);

   487 

   488 	buf.Copy(KUintFA, sizeof(KUintFA));

   489 	if (!UintVar(buf, 0xFA))

   490 		User::Leave(KErrGeneral);

   491 	

   492 	buf.Copy(KLenUintVAR4510, sizeof(KLenUintVAR4510));

   493 	if (!UintVar(buf, 0x4510))

   494 		User::Leave(KErrGeneral);

   495 

   496 	buf.Copy(KLenUintVARCorrupt, sizeof(KLenUintVARCorrupt));

   497 	if (!UintVar(buf, 0, KErrCorrupt))

   498 		User::Leave(KErrGeneral);

   499 

   500 	buf.Copy(KIntLongACorrupt, sizeof(KIntLongACorrupt));

   501 	if (!UintVar(buf, 0, KErrCorrupt))

   502 		User::Leave(KErrGeneral);

   503 	}

   504 

   505 

   506 

   507 

   508 //* VersionL */

   509 

   510 TBool CWSPDecodeTest::VersionL(RStringPool aPool, TPtrC8 aBuf, TPtrC8 aShouldBe, TInt aErr)

   511 	{

   512 	TInt success;

   513 	TWspPrimitiveDecoder dec(aBuf);

   514 	TBool retVal = EFalse;

   515 	RStringF val;

   516 	success = dec.VersionL(aPool,val);

   517 	CleanupClosePushL(val);

   518 	if (success < KErrNone && success == aErr)

   519 		retVal = ETrue;

   520 	else

   521 		{

   522 		RStringF should = aPool.OpenFStringL(aShouldBe);

   523 		retVal = val == should;

   524 		should.Close();

   525 		}

   526 	CleanupStack::PopAndDestroy(&val);

   527 	return retVal;

   528 	}

   529 

   530 void CWSPDecodeTest::VersionTestL()

   531 	{

   532 	_LIT(KTestText, "WSP Decode: Version");

   533 	iTestHarness->StartTestL(KTestText);

   534 	TRAPD(error, TestVersionL());

   535 	iTestHarness->EndTest(error);

   536 	User::LeaveIfError(error);

   537 	}

   538 

   539 void CWSPDecodeTest::TestVersionL()

   540 	{

   541 	RStringPool pool; 

   542 	pool.OpenL();

   543 	CleanupClosePushL(pool);

   544 	const TUint8 KVersion1[] = {0x9F};

   545 	const TUint8 KVersion11[] = {0x91};

   546 	const TUint8 KVersion610[] = {0xEA};

   547 	const TUint8 KVersion73[] = {0xF3};

   548 	const TUint8 KVersion00[] = {0x80};

   549 	const TUint8 KVersionStr[] = {'1','.','9','9',0x00};

   550 	TBuf8<255> buf;

   551 	

   552 	buf.Copy(KVersion1, sizeof(KVersion1));

   553 	if (!VersionL(pool, buf, _L8("1")))

   554 		User::Leave(KErrGeneral);

   555 

   556 	buf.Copy(KVersion11, sizeof(KVersion11));

   557 	if (!VersionL(pool, buf, _L8("1.1")))

   558 		User::Leave(KErrGeneral);

   559 

   560 	buf.Copy(KVersion610, sizeof(KVersion610));

   561 	if (!VersionL(pool, buf, _L8("6.10")))

   562 		User::Leave(KErrGeneral);

   563 

   564 	buf.Copy(KVersion73, sizeof(KVersion73));

   565 	if (!VersionL(pool, buf, _L8("7.3")))

   566 		User::Leave(KErrGeneral);

   567 

   568 	buf.Copy(KVersion00, sizeof(KVersion00));

   569 	if (!VersionL(pool, buf, _L8("0.0")))

   570 		User::Leave(KErrGeneral);

   571 	

   572 	buf.Copy(KVersionStr, sizeof(KVersionStr));

   573 	if (!VersionL(pool, buf, _L8("1.99")))

   574 		User::Leave(KErrGeneral);

   575 

   576 	CleanupStack::PopAndDestroy(&pool);

   577 	}

   578 

   579 

   580 //* Date */

   581 

   582 TBool CWSPDecodeTest::Date(TPtrC8 aBuf, TTime aShouldBe, TInt aErr)

   583 	{

   584 	TInt success;

   585 	TWspPrimitiveDecoder dec(aBuf);

   586 	TDateTime val;

   587 	success = dec.Date(val);

   588 	if (success < KErrNone && success == aErr)

   589 		return ETrue;

   590 

   591 	TTime time(val);

   592 	return time == aShouldBe;

   593 	}

   594 

   595 

   596 void CWSPDecodeTest::DateTestL()

   597 	{

   598 	_LIT(KTestText, "WSP Decode: Date");

   599 	iTestHarness->StartTestL(KTestText);

   600 	TRAPD(error, TestDateL());

   601 	iTestHarness->EndTest(error);

   602 	User::LeaveIfError(error);

   603 	}

   604 

   605 

   606 void CWSPDecodeTest::TestDateL()

   607 	{

   608 	// 1 long, value 0

   609 	const TUint8 KDate0[] = {0x01, 0x00};

   610 	const TUint8 KDateAprl132001[] = {0x04,0x3A,0xD6,0x41,0x80};

   611 	const TUint8 KDateDec132003[] = {0x04,0x3F,0xE2,0x8D,0x84};

   612 	TBuf8<255> buf;

   613 	TDateTime dt(1970,EJanuary,0,0,0,0,0);

   614 	TTime time1(dt);

   615 	buf.Copy(KDate0, sizeof(KDate0));

   616 	if (!Date(buf, time1))

   617 		User::Leave(KErrGeneral);

   618 

   619 	TTime time2(dt);

   620 	time2 += TTimeIntervalSeconds(0x3AD64180);

   621 	buf.Copy(KDateAprl132001, sizeof(KDateAprl132001));

   622 	if (!Date(buf, time2))

   623 		User::Leave(KErrGeneral);

   624 

   625 	TTime time3(dt);

   626 	time3 += TTimeIntervalSeconds(0x3FE28D84);

   627 	buf.Copy(KDateDec132003, sizeof(KDateDec132003));

   628 	if (!Date(buf, time3))

   629 		User::Leave(KErrGeneral);

   630 	}

   631 

   632 

   633 TInt CWSPDecodeTest::SegmenterCommonL(RStringPool aPool, TPtrC8 aHdr)

   634 	{

   635 	TInt err;

   636 	TWspField fld;

   637 	

   638 	// Pre-condition to create WSP header segment: Open the string pool 

   639 	// with the string table. Else program will raise a panic stringtable:4 

   640 	// ( EStringTableNotFound )

   641 	aPool.OpenL ( WSPDummy::Table );

   642 	TWspHeaderSegmenter segger(aPool, WSPDummy::Table, aHdr);

   643 

   644 	while ((err = segger.NextL(fld)) == KErrNone)

   645 		{

   646 		fld.iHdrName.Close();

   647 		}

   648 	return err;

   649 	}

   650 

   651 TBool CWSPDecodeTest::SegmenterL(RStringPool aPool, TPtrC8 aHdr)

   652 	{

   653 	TInt err = SegmenterCommonL(aPool,aHdr);

   654 	if (err != KErrNotFound)

   655 		return EFalse;

   656 	return ETrue;

   657 	}

   658 

   659 TBool CWSPDecodeTest::SegmenterExpectCorruptL(RStringPool aPool, TPtrC8 aHdr)

   660 	{

   661 	TInt err = SegmenterCommonL(aPool,aHdr);

   662 	if (err != KErrCorrupt)

   663 		return EFalse;

   664 	return ETrue;

   665 	}

   666 

   667 void CWSPDecodeTest::SegmenterTestL()

   668 	{

   669 	_LIT(KTestText, "WSP Decode: Segmenter");

   670 	iTestHarness->StartTestL(KTestText);

   671 	TRAPD(error, TestSegmenterL());

   672 	iTestHarness->EndTest(error);

   673 	User::LeaveIfError(error);

   674 	}

   675 

   676 

   677 void CWSPDecodeTest::TestSegmenterL()

   678 	{

   679 	TBuf8<255> buf;

   680 	RStringPool pool;

   681 	pool.OpenL();

   682 	CleanupClosePushL(pool);

   683 

   684 	// Test Headers

   685 	const TUint8 KAcceptAppVndWMLC[] = {0x80, 0x94};

   686 	const TUint8 KAcceptLanEngQ07[] = {0x82, 0x02, 0x99, 0x47};

   687 	const TUint8 KAcceptLanENSV[] = {0x82, 0x02, 0x83, 0xF0};

   688 	const TUint8 KDateThu23Apr1998134127GMT[] = {0x92, 0x04, 0x35, 0x3f, 0x45, 0x11};

   689 	const TUint8 KContentRangeBytes0499[] = {0x90, 0x03, 0x00, 0x88, 0x01};

   690 	const TUint8 KAcceptRangeNewRangeUnit[] = {0x84, 'n','e','w','-','r','a','n','g','e','-','u','n','i','t',0x00};

   691 	const TUint8 KXNewHdrFoo[] = {'X','-','n','e','w','-','H','e','a','d','e','r',0x00,'F','o','o',0x00};

   692 	const TUint8 KTwo[] = {0x80, 0x94, 0x81, 0x93};

   693 

   694 	const TUint8 KCorrupt1[] = {0x82};

   695 	buf.Copy(KCorrupt1, sizeof(KCorrupt1));

   696 	if (!SegmenterExpectCorruptL(pool, buf))

   697 		User::Leave(KErrGeneral);

   698 

   699 	const TUint8 KCorrupt2[] = {0x82, 0x02};

   700 	buf.Copy(KCorrupt2, sizeof(KCorrupt2));

   701 	if (!SegmenterExpectCorruptL(pool, buf))

   702 		User::Leave(KErrGeneral);

   703 

   704 	buf.Copy(KAcceptAppVndWMLC, sizeof(KAcceptAppVndWMLC));

   705 	if (!SegmenterL(pool, buf))

   706 		User::Leave(KErrGeneral);

   707 

   708 	buf.Copy(KAcceptLanEngQ07, sizeof(KAcceptLanEngQ07));

   709 	if (!SegmenterL(pool, buf))

   710 		User::Leave(KErrGeneral);

   711 

   712 	buf.Copy(KAcceptLanENSV, sizeof(KAcceptLanENSV));

   713 	if (!SegmenterL(pool, buf))

   714 		User::Leave(KErrGeneral);

   715 

   716 	buf.Copy(KDateThu23Apr1998134127GMT, sizeof(KDateThu23Apr1998134127GMT));

   717 	if (!SegmenterL(pool, buf))

   718 		User::Leave(KErrGeneral);

   719 

   720 	buf.Copy(KContentRangeBytes0499, sizeof(KContentRangeBytes0499));

   721 	if (!SegmenterL(pool, buf))

   722 		User::Leave(KErrGeneral);

   723 

   724 	buf.Copy(KAcceptRangeNewRangeUnit, sizeof(KAcceptRangeNewRangeUnit));

   725 	if (!SegmenterL(pool, buf))

   726 		User::Leave(KErrGeneral);

   727 	

   728 	buf.Copy(KXNewHdrFoo, sizeof(KXNewHdrFoo));

   729 	if (!SegmenterL(pool, buf))

   730 		User::Leave(KErrGeneral);

   731 

   732 	buf.Copy(KTwo, sizeof(KTwo));

   733 	if (!SegmenterL(pool, buf))

   734 		User::Leave(KErrGeneral);

   735 

   736 	CleanupStack::PopAndDestroy(&pool);

   737 	}

   738 

   739 /*

   740 

   741 void CWSPDecodeTest::XXXTestL()

   742 	{

   743 	_LIT(KTestText, "WSP Decode: XXX");

   744 	iTestHarness->StartTestL(KTestText);

   745 	TRAPD(error, TestXXXL());

   746 	iTestHarness->EndTest(error);

   747 	User::LeaveIfError(error);

   748 	}

   749 

   750 

   751 */