MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/genericservices/httputils/Test/t_wspcodec/cwspencodetest.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     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 CWSPEncodeTest.

    15 // 

    16 //

    17 

    18 

    19 #include "cwspencodetest.h"

    20 #include <wspencoder.h>

    21 

    22 

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

    24 	{

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

    26 	CleanupStack::PushL(self);

    27 	return self;

    28 	}

    29 

    30 

    31 CWSPEncodeTest::CWSPEncodeTest(CIpuTestHarness* aTestHarness):

    32 	iTestHarness(aTestHarness)

    33 	{}

    34 

    35 CWSPEncodeTest::~CWSPEncodeTest()

    36 	{}

    37 

    38 void CWSPEncodeTest::DoTestsL()

    39 	{

    40 	HeaderEncoderTestL();

    41 	ShortIntTestL();

    42 	LongIntTestL();

    43 	UintVarTestL();

    44 	StringTestL();

    45 	DateTestL();

    46 	}

    47 	

    48 

    49 void CWSPEncodeTest::HeaderEncoderTestL()

    50 	{

    51 	_LIT(KTestText, "WSP Encode: Header");

    52 	iTestHarness->StartTestL(KTestText);

    53 	TRAPD(error, TestHeaderEncoderL());

    54 	iTestHarness->EndTest(error);

    55 	User::LeaveIfError(error);

    56 	}

    57 

    58 void CWSPEncodeTest::TestHeaderEncoderL()

    59 	{

    60 	TInt err=0;

    61 

    62 	CWspHeaderEncoder* primEncoder = CWspHeaderEncoder::NewLC();

    63 

    64 	primEncoder->StartHeaderL(0x27);

    65 	primEncoder->StartValueLengthL();

    66 	primEncoder->AddUintVarL(0xff);

    67 	primEncoder->AddLongIntL(999999);

    68 	primEncoder->AddIntegerL(0x7F);

    69 	primEncoder->EndValueLengthL();

    70 	HBufC8* buf = primEncoder->EndHeaderL();

    71 	CleanupStack::PushL(buf);

    72 	CleanupStack::PopAndDestroy(2); //primEncoder, buf

    73 

    74 	User::LeaveIfError(err);

    75 	}

    76 

    77 

    78 void CWSPEncodeTest::ShortIntTestL()

    79 	{

    80 	_LIT(KTestText, "WSP Encode: ShortInt");

    81 	iTestHarness->StartTestL(KTestText);

    82 	TInt error = TestShortInt();

    83 	iTestHarness->EndTest(error);

    84 	User::LeaveIfError(error);

    85 	}

    86 

    87 

    88 TInt CWSPEncodeTest::TestShortInt()

    89 	{

    90 	TUint8 input;

    91 	TUint8 output;

    92 

    93 	// TWspPrimitiveEncoder::ShortInt

    94 	// Check 7 and 8 bit values. If 8bit notinh happens

    95 	input=0; // MIN input value

    96 	output = TWspPrimitiveEncoder::ShortInt(input);

    97 	if (output !=128)

    98 		return KErrGeneral;

    99 		

   100 	input=35; // MAX input value

   101 	output = TWspPrimitiveEncoder::ShortInt(input);

   102 	if (output !=163)

   103 		return KErrGeneral;

   104 

   105 	input=0x7F; // MAX input value

   106 	output = TWspPrimitiveEncoder::ShortInt(input);

   107 	if (output !=255)

   108 		return KErrGeneral;

   109 

   110 	input=0x80; // invalid value

   111 	output = TWspPrimitiveEncoder::ShortInt(input);

   112 	if (output !=0)

   113 		return KErrGeneral;

   114 

   115 	return KErrNone;

   116 	}

   117 

   118 

   119 void CWSPEncodeTest::LongIntTestL()

   120 	{

   121 	_LIT(KTestText, "WSP Encode: LongInt");

   122 	iTestHarness->StartTestL(KTestText);

   123 	TRAPD(error,TestLongIntL());

   124 	iTestHarness->EndTest(error);

   125 	User::LeaveIfError(error);

   126 	}

   127 

   128 void CWSPEncodeTest::TestLongIntL()

   129 	{

   130 	HBufC8* output=NULL;

   131 	TBuf8<255> buf;

   132 	TUint32 input;

   133 

   134 	const TUint8 KZeroValueLongInt[] = {0x01, 0x00};

   135 	const TUint8 K127LongInt[] = {0x01, 0x7F};

   136 	const TUint8 K255LongInt[] = {0x01, 0xFF};

   137 	const TUint8 K256LongInt[] = {0x02, 0x01, 0x00};

   138 	const TUint8 KFFFFLongInt[] = {0x02, 0xFF, 0xFF};

   139 	const TUint8 K10000LongInt[] = {0x03, 0x01, 0x00, 0x00};

   140 	const TUint8 KFFFFFFLongInt[] = {0x03, 0xFF, 0xFF, 0xFF};

   141 	const TUint8 K1000000LongInt[] = {0x04, 0x01, 0x00, 0x00, 0x00};

   142 	const TUint8 KFFFFFFFFLongInt[] = {0x04, 0xFF, 0xFF, 0xFF, 0xFF};

   143 

   144 	input=0;

   145 	output = TWspPrimitiveEncoder::LongIntL(input);

   146 	CleanupStack::PushL(output);

   147 	buf.Copy(KZeroValueLongInt, sizeof(KZeroValueLongInt));

   148 	if ((*output).CompareF(buf)!=0)

   149 		User::Leave(KErrGeneral);

   150 	CleanupStack::PopAndDestroy(output);

   151 

   152 	input=127;

   153 	output = TWspPrimitiveEncoder::LongIntL(input);

   154 	CleanupStack::PushL(output);

   155 	buf.Copy(K127LongInt, sizeof(K127LongInt));

   156 	if ((*output).CompareF(buf)!=0)

   157 		User::Leave(KErrGeneral);

   158 	CleanupStack::PopAndDestroy(output);

   159 

   160 	input=255;

   161 	output = TWspPrimitiveEncoder::LongIntL(input);

   162 	CleanupStack::PushL(output);

   163 	buf.Copy(K255LongInt, sizeof(K255LongInt));

   164 	if ((*output).CompareF(buf)!=0)

   165 		User::Leave(KErrGeneral);

   166 	CleanupStack::PopAndDestroy(output);

   167 

   168 	input=256;

   169 	output = TWspPrimitiveEncoder::LongIntL(input);

   170 	CleanupStack::PushL(output);

   171 	buf.Copy(K256LongInt, sizeof(K256LongInt));

   172 	if ((*output).CompareF(buf)!=0)

   173 		User::Leave(KErrGeneral);

   174 	CleanupStack::PopAndDestroy(output);

   175 

   176 	input=0xFFFF;

   177 	output = TWspPrimitiveEncoder::LongIntL(input);

   178 	CleanupStack::PushL(output);

   179 	buf.Copy(KFFFFLongInt, sizeof(KFFFFLongInt));

   180 	if ((*output).CompareF(buf)!=0)

   181 		User::Leave(KErrGeneral);

   182 	CleanupStack::PopAndDestroy(output);

   183 

   184 	input=0x10000;

   185 	output = TWspPrimitiveEncoder::LongIntL(input);

   186 	CleanupStack::PushL(output);

   187 	buf.Copy(K10000LongInt, sizeof(K10000LongInt));

   188 	if ((*output).CompareF(buf)!=0)

   189 		User::Leave(KErrGeneral);

   190 	CleanupStack::PopAndDestroy(output);

   191 

   192 	input=0xFFFFFF;

   193 	output = TWspPrimitiveEncoder::LongIntL(input);

   194 	CleanupStack::PushL(output);

   195 	buf.Copy(KFFFFFFLongInt, sizeof(KFFFFFFLongInt));

   196 	if ((*output).CompareF(buf)!=0)

   197 		User::Leave(KErrGeneral);

   198 	CleanupStack::PopAndDestroy(output);

   199 

   200 	input=0x1000000;

   201 	output = TWspPrimitiveEncoder::LongIntL(input);

   202 	CleanupStack::PushL(output);

   203 	buf.Copy(K1000000LongInt, sizeof(K1000000LongInt));

   204 	if ((*output).CompareF(buf)!=0)

   205 		User::Leave(KErrGeneral);

   206 	CleanupStack::PopAndDestroy(output);

   207 

   208 	input=0xFFFFFFFF;

   209 	output = TWspPrimitiveEncoder::LongIntL(input);

   210 	CleanupStack::PushL(output);

   211 	buf.Copy(KFFFFFFFFLongInt, sizeof(KFFFFFFFFLongInt));

   212 	if ((*output).CompareF(buf)!=0)

   213 		User::Leave(KErrGeneral);

   214 	CleanupStack::PopAndDestroy(output);

   215 	}

   216 

   217 

   218 void CWSPEncodeTest::UintVarTestL()

   219 	{

   220 	_LIT(KTestText, "WSP Encode: UintVar");

   221 	iTestHarness->StartTestL(KTestText);

   222 	TRAPD(error,TestUintVarL());

   223 	iTestHarness->EndTest(error);

   224 	User::LeaveIfError(error);

   225 	}

   226 

   227 void CWSPEncodeTest::TestUintVarL()

   228 	{

   229 

   230 	HBufC8* output=NULL;

   231 	TBuf8<255> buf;

   232 	TUint32 input;

   233 

   234 	const TUint8 KMinValue[] = {0x00};

   235 	const TUint8 KMaxValue[] = {0x8F, 0xFF, 0xFF, 0xFF, 0x7F};

   236 

   237 	const TUint8 K7bitBoundaryLower[] = {0x7F};

   238 	const TUint8 K7bitBoundaryUpper[] = {0x81, 0x00};

   239 

   240 	const TUint8 K14bitBoundaryLower[] = {0xFF, 0x7F};

   241 	const TUint8 K14bitBoundaryUpper[] = {0x81, 0x80, 0x00};

   242 

   243 	const TUint8 K21bitBoundaryLower[] = {0xFF, 0xFF, 0x7F};

   244 	const TUint8 K21bitBoundaryUpper[] = {0x81, 0x80, 0x80, 0x00};

   245 	const TUint8 K28bitBoundaryLower[] = {0xFF, 0xFF, 0xFF, 0x7F};

   246 	const TUint8 K28bitBoundaryUpper[] = {0x81, 0x80, 0x80, 0x80, 0x00};

   247 

   248 	input=0;

   249 	output = TWspPrimitiveEncoder::UintVarL(input);

   250 	CleanupStack::PushL(output);

   251 	buf.Copy(KMinValue, sizeof(KMinValue));

   252 	if ((*output).CompareF(buf)!=0)

   253 		User::Leave(KErrGeneral);

   254 	CleanupStack::PopAndDestroy(output);

   255 

   256 	input=0xFFFFFFFF;

   257 	output = TWspPrimitiveEncoder::UintVarL(input);

   258 	CleanupStack::PushL(output);

   259 	buf.Copy(KMaxValue, sizeof(KMaxValue));

   260 	if ((*output).CompareF(buf)!=0)

   261 		User::Leave(KErrGeneral);

   262 	CleanupStack::PopAndDestroy(output);

   263 

   264 	input=0x7F;

   265 	output = TWspPrimitiveEncoder::UintVarL(input);

   266 	CleanupStack::PushL(output);

   267 	buf.Copy(K7bitBoundaryLower, sizeof(K7bitBoundaryLower));

   268 	if ((*output).CompareF(buf)!=0)

   269 		User::Leave(KErrGeneral);

   270 	CleanupStack::PopAndDestroy(output);

   271 

   272 	input=0x80;

   273 	output = TWspPrimitiveEncoder::UintVarL(input);

   274 	CleanupStack::PushL(output);

   275 	buf.Copy(K7bitBoundaryUpper, sizeof(K7bitBoundaryUpper));

   276 	if ((*output).CompareF(buf)!=0)

   277 		User::Leave(KErrGeneral);

   278 	CleanupStack::PopAndDestroy(output);

   279 

   280 	input=0x3FFF;

   281 	output = TWspPrimitiveEncoder::UintVarL(input);

   282 	CleanupStack::PushL(output);

   283 	buf.Copy(K14bitBoundaryLower, sizeof(K14bitBoundaryLower));

   284 	if ((*output).CompareF(buf)!=0)

   285 		User::Leave(KErrGeneral);

   286 	CleanupStack::PopAndDestroy(output);

   287 

   288 	input=0x4000;

   289 	output = TWspPrimitiveEncoder::UintVarL(input);

   290 	CleanupStack::PushL(output);

   291 	buf.Copy(K14bitBoundaryUpper, sizeof(K14bitBoundaryUpper));

   292 	if ((*output).CompareF(buf)!=0)

   293 		User::Leave(KErrGeneral);

   294 	CleanupStack::PopAndDestroy(output);

   295 

   296 	input=0x1FFFFF;

   297 	output = TWspPrimitiveEncoder::UintVarL(input);

   298 	CleanupStack::PushL(output);

   299 	buf.Copy(K21bitBoundaryLower, sizeof(K21bitBoundaryLower));

   300 	if ((*output).CompareF(buf)!=0)

   301 		User::Leave(KErrGeneral);

   302 	CleanupStack::PopAndDestroy(output);

   303 

   304 	input=0x200000;

   305 	output = TWspPrimitiveEncoder::UintVarL(input);

   306 	CleanupStack::PushL(output);

   307 	buf.Copy(K21bitBoundaryUpper, sizeof(K21bitBoundaryUpper));

   308 	if ((*output).CompareF(buf)!=0)

   309 		User::Leave(KErrGeneral);

   310 	CleanupStack::PopAndDestroy(output);

   311 

   312 	input=0xFFFFFFF;

   313 	output = TWspPrimitiveEncoder::UintVarL(input);

   314 	CleanupStack::PushL(output);

   315 	buf.Copy(K28bitBoundaryLower, sizeof(K28bitBoundaryLower));

   316 	if ((*output).CompareF(buf)!=0)

   317 		User::Leave(KErrGeneral);

   318 	CleanupStack::PopAndDestroy(output);

   319 

   320 	input=0x10000000;

   321 	output = TWspPrimitiveEncoder::UintVarL(input);

   322 	CleanupStack::PushL(output);

   323 	buf.Copy(K28bitBoundaryUpper, sizeof(K28bitBoundaryUpper));

   324 	if ((*output).CompareF(buf)!=0)

   325 		User::Leave(KErrGeneral);

   326 	CleanupStack::PopAndDestroy(output);

   327 

   328 	}

   329 

   330 

   331 void CWSPEncodeTest::StringTestL()

   332 	{

   333 	_LIT(KTestText, "WSP Encode: String");

   334 	iTestHarness->StartTestL(KTestText);

   335 	TRAPD(error,TestStringL());

   336 	iTestHarness->EndTest(error);

   337 	User::LeaveIfError(error);

   338 	}

   339 

   340 void CWSPEncodeTest::TestStringL()

   341 	{

   342 	TBuf8<255> buf;

   343 

   344 	// Test 1. A regular string

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

   346 	_LIT8(KTestString1,"X-new-HeaderFoo");

   347 

   348 	// Test 2. A quoted string

   349 	const TUint8 KTestStringResult2[] = {'\"','X','-','n','e','w','-','H','e','a','d','e','r','F','o','o',0x00};

   350 	_LIT8(KTestString2,"\"X-new-HeaderFoo\"");

   351 

   352 	// Test 3. A string beginning with an Upper-Ascii character

   353 	const TUint8 KTestStringResult3[] = {0x7F,0x80,'X','-','n','e','w','-','H','e','a','d','e','r','F','o','o',0x00};

   354 	const TUint8 KTestString3[] = {0x80,'X','-','n','e','w','-','H','e','a','d','e','r','F','o','o'};

   355 

   356 	HBufC8* output = TWspPrimitiveEncoder::TextStringL(KTestString1);

   357 	CleanupStack::PushL(output);

   358 	buf.Copy(KTestStringResult1, sizeof(KTestStringResult1));

   359 	if ((*output).CompareF(buf)!=0)

   360 		User::Leave(KErrGeneral);

   361 	CleanupStack::PopAndDestroy(output);

   362 

   363 

   364 	output = TWspPrimitiveEncoder::TextStringL(KTestString2);

   365 	CleanupStack::PushL(output);

   366 	buf.Copy(KTestStringResult2, sizeof(KTestStringResult2));

   367 	if ((*output).CompareF(buf)!=0)

   368 		User::Leave(KErrGeneral);

   369 	CleanupStack::PopAndDestroy(output);

   370 

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

   372 	output = TWspPrimitiveEncoder::TextStringL(buf);

   373 	CleanupStack::PushL(output);

   374 	buf.Copy(KTestStringResult3, sizeof(KTestStringResult3));

   375 	if ((*output).CompareF(buf)!=0)

   376 		User::Leave(KErrGeneral);

   377 	CleanupStack::PopAndDestroy(output);

   378 	}

   379 

   380 

   381 void CWSPEncodeTest::DateTestL()

   382 	{

   383 	_LIT(KTestText, "WSP Encode: Date");

   384 	iTestHarness->StartTestL(KTestText);

   385 	TRAPD(error,TestDateL());

   386 	iTestHarness->EndTest(error);

   387 	User::LeaveIfError(error);

   388 	}

   389 

   390 

   391 void CWSPEncodeTest::TestDateL()

   392 	{

   393 	TBuf8<255> buf;

   394 

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

   396 

   397 	TDateTime date(1970,EJanuary,0,0,0,0,0);

   398 	

   399 	HBufC8* output = TWspPrimitiveEncoder::DateL(date);

   400 	CleanupStack::PushL(output);

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

   402 	if((*output).CompareF(buf)!=0)

   403 		User::Leave(KErrGeneral);

   404 	CleanupStack::PopAndDestroy(output);

   405 	}

   406 

   407
Symaptic