1 /*

     2 * Copyright (c) 2001 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 */

    17 

    18 

    19 /**

    20 	@file WspHeaderWriterUnitTest.cpp

    21 	Comments : The unit test class implementations for the CWspHeaderWriter class.

    22  */

    23 

    24 #include "WspHeaderWriterUnitTest.h"

    25 

    26 // ______________________________________________________________________________

    27 //

    28 _LIT(KWspHeaderWriterCreateAndDestroyUnitTest,"CWspHeaderWriter_CreateAndDestroy_UnitTest");

    29 

    30 CWspHeaderWriter_CreateAndDestroy_UnitTest* CWspHeaderWriter_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,

    31 											MUnitTestObserver& aObserver)

    32 	{

    33 	CWspHeaderWriter_CreateAndDestroy_UnitTest* self = 

    34 					new(ELeave) CWspHeaderWriter_CreateAndDestroy_UnitTest(aDataLogger,

    35 																aObserver);

    36 	CleanupStack::PushL(self);

    37 	self->ConstructL();

    38 	CleanupStack::Pop(self);

    39 	return self; 

    40 	}

    41 

    42 inline TInt CWspHeaderWriter_CreateAndDestroy_UnitTest::RunError(TInt aError)

    43 	{

    44 	// The RunL left so chain to the base first and then cleanup

    45 	TInt error = CUnitTest::RunError(aError);	// Chain to base

    46 	delete iUTContext;

    47 	iUTContext = NULL;

    48 	delete iStateAccessor;

    49 	iStateAccessor = NULL;

    50 	/* delete any validators used */

    51 	delete iCtorValidator;

    52 	iCtorValidator = NULL;

    53 	delete iDtorValidator;

    54 	iDtorValidator = NULL;

    55 	return error;

    56 	}

    57 

    58 inline CWspHeaderWriter_CreateAndDestroy_UnitTest::~CWspHeaderWriter_CreateAndDestroy_UnitTest()

    59 	{

    60 	// Simply delete our test class instance

    61 	delete iUTContext;

    62 	delete iStateAccessor;

    63 	/* delete any validators used */

    64 	delete iCtorValidator;

    65 	delete iDtorValidator;

    66 	}

    67 

    68 inline CWspHeaderWriter_CreateAndDestroy_UnitTest::CWspHeaderWriter_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    69 																	MUnitTestObserver& aObserver)

    70 : CUnitTest(KWspHeaderWriterCreateAndDestroyUnitTest, aDataLogger, aObserver)

    71 	{

    72 	//Do nothing

    73 	}

    74 

    75 // Now the Individual transitions need to be added.

    76 inline void CWspHeaderWriter_CreateAndDestroy_UnitTest::ConstructL()

    77 	{

    78 	// Perform the base class initialization

    79 	UnitTestConstructL();

    80 

    81 	// Create the Unit test state accessor

    82 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

    83 	// Construct the Unit test context.

    84 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

    85 	iUTContext->ConstructL(WSP::EAccept);

    86 	

    87 	// Add the Transitions in the order they are to run

    88 	// C'tor first, D'tor last...

    89 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

    90 		using constructor and destuctor validators */

    91 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

    92 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

    93 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

    94 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

    95 	}

    96 

    97 // ______________________________________________________________________________

    98 //

    99 _LIT(KWspHeaderWriterUserAgentUnitTest,"CWspHeaderWriter_UserAgent_UnitTest");

   100 

   101 CWspHeaderWriter_UserAgent_UnitTest* CWspHeaderWriter_UserAgent_UnitTest::NewL(CDataLogger& aDataLogger,

   102 											MUnitTestObserver& aObserver)

   103 	{

   104 	CWspHeaderWriter_UserAgent_UnitTest* self = 

   105 					new(ELeave) CWspHeaderWriter_UserAgent_UnitTest(aDataLogger,

   106 																aObserver);

   107 	CleanupStack::PushL(self);

   108 	self->ConstructL();

   109 	CleanupStack::Pop(self);

   110 	return self; 

   111 	}

   112 

   113 inline TInt CWspHeaderWriter_UserAgent_UnitTest::RunError(TInt aError)

   114 	{

   115 	// The RunL left so chain to the base first and then cleanup

   116 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   117 	delete iUTContext;

   118 	iUTContext = NULL;

   119 	delete iStateAccessor;

   120 	iStateAccessor = NULL;

   121 	/* delete any validators used */

   122 	delete iCtorValidator;

   123 	iCtorValidator = NULL;

   124 	delete iUserAgentValidator;

   125 	iUserAgentValidator = NULL;

   126 	delete iDtorValidator;

   127 	iDtorValidator = NULL;

   128 	return error;

   129 	}

   130 

   131 inline CWspHeaderWriter_UserAgent_UnitTest::~CWspHeaderWriter_UserAgent_UnitTest()

   132 	{

   133 	// Simply delete our test class instance

   134 	delete iUTContext;

   135 	delete iStateAccessor;

   136 	/* delete any validators used */

   137 	delete iCtorValidator;

   138 	delete iUserAgentValidator;

   139 	delete iDtorValidator;

   140 	}

   141 

   142 inline CWspHeaderWriter_UserAgent_UnitTest::CWspHeaderWriter_UserAgent_UnitTest(CDataLogger& aDataLogger,

   143 																	MUnitTestObserver& aObserver)

   144 : CUnitTest(KWspHeaderWriterUserAgentUnitTest, aDataLogger, aObserver)

   145 	{

   146 	//Do nothing

   147 	}

   148 

   149 // Now the Individual transitions need to be added.

   150 inline void CWspHeaderWriter_UserAgent_UnitTest::ConstructL()

   151 	{

   152 	// Perform the base class initialization

   153 	UnitTestConstructL();

   154 

   155 	// Create the Unit test state accessor

   156 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   157 	// Construct the Unit test context.

   158 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   159 	iUTContext->ConstructL(WSP::EUserAgent);

   160 	

   161 	_LIT8(KTxtData, "user-agent-text");

   162 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtData);

   163 	CleanupClosePushL(stringVal);

   164 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   165 	CleanupStack::PushL(part1);

   166 	iUTContext->iTestHeader->SetPartL(part1, 0);

   167 	CleanupStack::Pop(part1);

   168 	CleanupStack::PopAndDestroy(&stringVal);

   169 

   170 	TBuf8<256> expectedBuf;

   171 	expectedBuf.Append(KTxtData);

   172 	expectedBuf.Append(0x00);

   173 	iUTContext->SetExpectedL(expectedBuf);

   174 

   175 	// Add the Transitions in the order they are to run

   176 	// C'tor first, D'tor last...

   177 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   178 		using constructor and destuctor validators */

   179 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   180 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   181 	iUserAgentValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   182 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iUserAgentValidator));

   183 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   184 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   185 	}

   186 

   187 // ______________________________________________________________________________

   188 //

   189 _LIT(KWspHeaderWriterUserAgentNullTextUnitTest,"CWspHeaderWriter_UserAgentNullText_UnitTest");

   190 

   191 CWspHeaderWriter_UserAgentNullText_UnitTest* CWspHeaderWriter_UserAgentNullText_UnitTest::NewL(CDataLogger& aDataLogger,

   192 											MUnitTestObserver& aObserver)

   193 	{

   194 	CWspHeaderWriter_UserAgentNullText_UnitTest* self = 

   195 					new(ELeave) CWspHeaderWriter_UserAgentNullText_UnitTest(aDataLogger,

   196 																aObserver);

   197 	CleanupStack::PushL(self);

   198 	self->ConstructL();

   199 	CleanupStack::Pop(self);

   200 	return self; 

   201 	}

   202 

   203 inline TInt CWspHeaderWriter_UserAgentNullText_UnitTest::RunError(TInt aError)

   204 	{

   205 	// The RunL left so chain to the base first and then cleanup

   206 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   207 	delete iUTContext;

   208 	iUTContext = NULL;

   209 	delete iStateAccessor;

   210 	iStateAccessor = NULL;

   211 	/* delete any validators used */

   212 	delete iCtorValidator;

   213 	iCtorValidator = NULL;

   214 	delete iUserAgentNullTextValidator;

   215 	iUserAgentNullTextValidator = NULL;

   216 	delete iDtorValidator;

   217 	iDtorValidator = NULL;

   218 	return error;

   219 	}

   220 

   221 inline CWspHeaderWriter_UserAgentNullText_UnitTest::~CWspHeaderWriter_UserAgentNullText_UnitTest()

   222 	{

   223 	// Simply delete our test class instance

   224 	delete iUTContext;

   225 	delete iStateAccessor;

   226 	/* delete any validators used */

   227 	delete iCtorValidator;

   228 	delete iUserAgentNullTextValidator;

   229 	delete iDtorValidator;

   230 	}

   231 

   232 inline CWspHeaderWriter_UserAgentNullText_UnitTest::CWspHeaderWriter_UserAgentNullText_UnitTest(CDataLogger& aDataLogger,

   233 																	MUnitTestObserver& aObserver)

   234 : CUnitTest(KWspHeaderWriterUserAgentNullTextUnitTest, aDataLogger, aObserver)

   235 	{

   236 	//Do nothing

   237 	}

   238 

   239 // Now the Individual transitions need to be added.

   240 inline void CWspHeaderWriter_UserAgentNullText_UnitTest::ConstructL()

   241 	{

   242 	// Perform the base class initialization

   243 	UnitTestConstructL();

   244 

   245 	// Create the Unit test state accessor

   246 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   247 	// Construct the Unit test context.

   248 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   249 	iUTContext->ConstructL(WSP::EUserAgent);

   250 	

   251 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KNullDesC8());

   252 	CleanupClosePushL(stringVal);

   253 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   254 	CleanupStack::PushL(part1);

   255 	iUTContext->iTestHeader->SetPartL(part1, 0);

   256 	CleanupStack::Pop(part1);

   257 	CleanupStack::PopAndDestroy(&stringVal);

   258 

   259 	TBuf8<256> expectedBuf;

   260 	expectedBuf.Append(0x00);

   261 	iUTContext->SetExpectedL(expectedBuf);

   262 

   263 	// Add the Transitions in the order they are to run

   264 	// C'tor first, D'tor last...

   265 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   266 		using constructor and destuctor validators */

   267 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   268 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   269 	iUserAgentNullTextValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   270 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iUserAgentNullTextValidator));

   271 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   272 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   273 	}

   274 

   275 // ______________________________________________________________________________

   276 //

   277 _LIT(KWspHeaderWriterAuthorizationBasicUnitTest,"CWspHeaderWriter_AuthorizationBasic_UnitTest");

   278 

   279 CWspHeaderWriter_AuthorizationBasic_UnitTest* CWspHeaderWriter_AuthorizationBasic_UnitTest::NewL(CDataLogger& aDataLogger,

   280 											MUnitTestObserver& aObserver)

   281 	{

   282 	CWspHeaderWriter_AuthorizationBasic_UnitTest* self = 

   283 					new(ELeave) CWspHeaderWriter_AuthorizationBasic_UnitTest(aDataLogger,

   284 																aObserver);

   285 	CleanupStack::PushL(self);

   286 	self->ConstructL();

   287 	CleanupStack::Pop(self);

   288 	return self; 

   289 	}

   290 

   291 inline TInt CWspHeaderWriter_AuthorizationBasic_UnitTest::RunError(TInt aError)

   292 	{

   293 	// The RunL left so chain to the base first and then cleanup

   294 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   295 	delete iUTContext;

   296 	iUTContext = NULL;

   297 	delete iStateAccessor;

   298 	iStateAccessor = NULL;

   299 	/* delete any validators used */

   300 	delete iCtorValidator;

   301 	iCtorValidator = NULL;

   302 	delete iAuthorizationBasicValidator;

   303 	iAuthorizationBasicValidator = NULL;

   304 	delete iDtorValidator;

   305 	iDtorValidator = NULL;

   306 	return error;

   307 	}

   308 

   309 inline CWspHeaderWriter_AuthorizationBasic_UnitTest::~CWspHeaderWriter_AuthorizationBasic_UnitTest()

   310 	{

   311 	// Simply delete our test class instance

   312 	delete iUTContext;

   313 	delete iStateAccessor;

   314 	/* delete any validators used */

   315 	delete iCtorValidator;

   316 	delete iAuthorizationBasicValidator;

   317 	delete iDtorValidator;

   318 	}

   319 

   320 inline CWspHeaderWriter_AuthorizationBasic_UnitTest::CWspHeaderWriter_AuthorizationBasic_UnitTest(CDataLogger& aDataLogger,

   321 																	MUnitTestObserver& aObserver)

   322 : CUnitTest(KWspHeaderWriterAuthorizationBasicUnitTest, aDataLogger, aObserver)

   323 	{

   324 	//Do nothing

   325 	}

   326 

   327 // Now the Individual transitions need to be added.

   328 inline void CWspHeaderWriter_AuthorizationBasic_UnitTest::ConstructL()

   329 	{

   330 	// Perform the base class initialization

   331 	UnitTestConstructL();

   332 

   333 	// Create the Unit test state accessor

   334 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   335 	// Construct the Unit test context.

   336 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   337 	iUTContext->ConstructL(WSP::EAuthorization);

   338 	

   339 	// Part1

   340 	_LIT8(KTxtBasic, "Basic");

   341 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtBasic);

   342 	CleanupClosePushL(stringVal);

   343 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   344 	CleanupStack::PushL(part1);

   345 	iUTContext->iTestHeader->SetPartL(part1, 0);

   346 	CleanupStack::Pop(part1);

   347 	CleanupStack::PopAndDestroy(&stringVal);

   348 

   349 	// Part2

   350 	_LIT8(KTxtUser, "myuserid");

   351 	RStringF stringVal2 = iUTContext->iStrPool.OpenFStringL(KTxtUser);

   352 	CleanupClosePushL(stringVal2);

   353 	CHeaderFieldPart* part2 = CHeaderFieldPart::NewL(stringVal2);

   354 	CleanupStack::PushL(part2);

   355 	iUTContext->iTestHeader->SetPartL(part2, 1);

   356 	CleanupStack::Pop(part2);

   357 	CleanupStack::PopAndDestroy(&stringVal2);

   358 

   359 	// Part2

   360 	_LIT8(KTxtPassword, "mypass");

   361 	RStringF stringVal3 = iUTContext->iStrPool.OpenFStringL(KTxtPassword);

   362 	CleanupClosePushL(stringVal3);

   363 	CHeaderFieldPart* part3 = CHeaderFieldPart::NewL(stringVal3);

   364 	CleanupStack::PushL(part3);

   365 	iUTContext->iTestHeader->SetPartL(part3, 2);

   366 	CleanupStack::Pop(part3);

   367 	CleanupStack::PopAndDestroy(&stringVal3);

   368 

   369 	TBuf8<256> expectedBuf;

   370 	expectedBuf.Append(0x11); // value-length for 17

   371 	expectedBuf.Append(0x80);

   372 	expectedBuf.Append(KTxtUser);

   373 	expectedBuf.Append(0x00);

   374 	expectedBuf.Append(KTxtPassword);

   375 	expectedBuf.Append(0x00);

   376 	iUTContext->SetExpectedL(expectedBuf);

   377 

   378 	// Add the Transitions in the order they are to run

   379 	// C'tor first, D'tor last...

   380 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   381 		using constructor and destuctor validators */

   382 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   383 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   384 	iAuthorizationBasicValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   385 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iAuthorizationBasicValidator));

   386 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   387 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   388 	}

   389 

   390 // ______________________________________________________________________________

   391 //

   392 _LIT(KWspHeaderWriterAuthorizationBasicNullUserUnitTest,"CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest");

   393 

   394 CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest* CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest::NewL(CDataLogger& aDataLogger,

   395 											MUnitTestObserver& aObserver)

   396 	{

   397 	CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest* self = 

   398 					new(ELeave) CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest(aDataLogger,

   399 																aObserver);

   400 	CleanupStack::PushL(self);

   401 	self->ConstructL();

   402 	CleanupStack::Pop(self);

   403 	return self; 

   404 	}

   405 

   406 inline TInt CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest::RunError(TInt aError)

   407 	{

   408 	// The RunL left so chain to the base first and then cleanup

   409 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   410 	delete iUTContext;

   411 	iUTContext = NULL;

   412 	delete iStateAccessor;

   413 	iStateAccessor = NULL;

   414 	/* delete any validators used */

   415 	delete iCtorValidator;

   416 	iCtorValidator = NULL;

   417 	delete iAuthorizationBasicNullUserValidator;

   418 	iAuthorizationBasicNullUserValidator = NULL;

   419 	delete iDtorValidator;

   420 	iDtorValidator = NULL;

   421 	return error;

   422 	}

   423 

   424 inline CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest::~CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest()

   425 	{

   426 	// Simply delete our test class instance

   427 	delete iUTContext;

   428 	delete iStateAccessor;

   429 	/* delete any validators used */

   430 	delete iCtorValidator;

   431 	delete iAuthorizationBasicNullUserValidator;

   432 	delete iDtorValidator;

   433 	}

   434 

   435 inline CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest::CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest(CDataLogger& aDataLogger,

   436 																	MUnitTestObserver& aObserver)

   437 : CUnitTest(KWspHeaderWriterAuthorizationBasicNullUserUnitTest, aDataLogger, aObserver)

   438 	{

   439 	//Do nothing

   440 	}

   441 

   442 // Now the Individual transitions need to be added.

   443 inline void CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest::ConstructL()

   444 	{

   445 	// Perform the base class initialization

   446 	UnitTestConstructL();

   447 

   448 	// Create the Unit test state accessor

   449 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   450 	// Construct the Unit test context.

   451 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   452 	iUTContext->ConstructL(WSP::EAuthorization);

   453 	

   454 	// Part1

   455 	_LIT8(KTxtBasic, "Basic");

   456 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtBasic);

   457 	CleanupClosePushL(stringVal);

   458 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   459 	CleanupStack::PushL(part1);

   460 	iUTContext->iTestHeader->SetPartL(part1, 0);

   461 	CleanupStack::Pop(part1);

   462 	CleanupStack::PopAndDestroy(&stringVal);

   463 

   464 	// Part2

   465 	RStringF stringVal2 = iUTContext->iStrPool.OpenFStringL(KNullDesC8());

   466 	CleanupClosePushL(stringVal2);

   467 	CHeaderFieldPart* part2 = CHeaderFieldPart::NewL(stringVal2);

   468 	CleanupStack::PushL(part2);

   469 	iUTContext->iTestHeader->SetPartL(part2, 1);

   470 	CleanupStack::Pop(part2);

   471 	CleanupStack::PopAndDestroy(&stringVal2);

   472 

   473 	// Part2

   474 	_LIT8(KTxtPassword, "mypass");

   475 	RStringF stringVal3 = iUTContext->iStrPool.OpenFStringL(KTxtPassword);

   476 	CleanupClosePushL(stringVal3);

   477 	CHeaderFieldPart* part3 = CHeaderFieldPart::NewL(stringVal3);

   478 	CleanupStack::PushL(part3);

   479 	iUTContext->iTestHeader->SetPartL(part3, 2);

   480 	CleanupStack::Pop(part3);

   481 	CleanupStack::PopAndDestroy(&stringVal3);

   482 

   483 	TBuf8<256> expectedBuf;

   484 	expectedBuf.Append(0x09); // value-length for 9

   485 	expectedBuf.Append(0x80);

   486 	expectedBuf.Append(0x00);

   487 	expectedBuf.Append(KTxtPassword);

   488 	expectedBuf.Append(0x00);

   489 	iUTContext->SetExpectedL(expectedBuf);

   490 

   491 	// Add the Transitions in the order they are to run

   492 	// C'tor first, D'tor last...

   493 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   494 		using constructor and destuctor validators */

   495 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   496 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   497 	iAuthorizationBasicNullUserValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   498 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iAuthorizationBasicNullUserValidator));

   499 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   500 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   501 	}

   502 

   503 // ______________________________________________________________________________

   504 //

   505 _LIT(KWspHeaderWriterBasicNullPasswordUnitTest,"CWspHeaderWriter_BasicNullPassword_UnitTest");

   506 

   507 CWspHeaderWriter_BasicNullPassword_UnitTest* CWspHeaderWriter_BasicNullPassword_UnitTest::NewL(CDataLogger& aDataLogger,

   508 											MUnitTestObserver& aObserver)

   509 	{

   510 	CWspHeaderWriter_BasicNullPassword_UnitTest* self = 

   511 					new(ELeave) CWspHeaderWriter_BasicNullPassword_UnitTest(aDataLogger,

   512 																aObserver);

   513 	CleanupStack::PushL(self);

   514 	self->ConstructL();

   515 	CleanupStack::Pop(self);

   516 	return self; 

   517 	}

   518 

   519 inline TInt CWspHeaderWriter_BasicNullPassword_UnitTest::RunError(TInt aError)

   520 	{

   521 	// The RunL left so chain to the base first and then cleanup

   522 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   523 	delete iUTContext;

   524 	iUTContext = NULL;

   525 	delete iStateAccessor;

   526 	iStateAccessor = NULL;

   527 	/* delete any validators used */

   528 	delete iCtorValidator;

   529 	iCtorValidator = NULL;

   530 	delete iBasicNullPasswordValidator;

   531 	iBasicNullPasswordValidator = NULL;

   532 	delete iDtorValidator;

   533 	iDtorValidator = NULL;

   534 	return error;

   535 	}

   536 

   537 inline CWspHeaderWriter_BasicNullPassword_UnitTest::~CWspHeaderWriter_BasicNullPassword_UnitTest()

   538 	{

   539 	// Simply delete our test class instance

   540 	delete iUTContext;

   541 	delete iStateAccessor;

   542 	/* delete any validators used */

   543 	delete iCtorValidator;

   544 	delete iBasicNullPasswordValidator;

   545 	delete iDtorValidator;

   546 	}

   547 

   548 inline CWspHeaderWriter_BasicNullPassword_UnitTest::CWspHeaderWriter_BasicNullPassword_UnitTest(CDataLogger& aDataLogger,

   549 																	MUnitTestObserver& aObserver)

   550 : CUnitTest(KWspHeaderWriterBasicNullPasswordUnitTest, aDataLogger, aObserver)

   551 	{

   552 	//Do nothing

   553 	}

   554 

   555 // Now the Individual transitions need to be added.

   556 inline void CWspHeaderWriter_BasicNullPassword_UnitTest::ConstructL()

   557 	{

   558 	// Perform the base class initialization

   559 	UnitTestConstructL();

   560 

   561 	// Create the Unit test state accessor

   562 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   563 	// Construct the Unit test context.

   564 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   565 	iUTContext->ConstructL(WSP::EAuthorization);

   566 	

   567 	// Part1

   568 	_LIT8(KTxtBasic, "Basic");

   569 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtBasic);

   570 	CleanupClosePushL(stringVal);

   571 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   572 	CleanupStack::PushL(part1);

   573 	iUTContext->iTestHeader->SetPartL(part1, 0);

   574 	CleanupStack::Pop(part1);

   575 	CleanupStack::PopAndDestroy(&stringVal);

   576 

   577 	// Part2

   578 	_LIT8(KTxtUser, "myuserid");

   579 	RStringF stringVal2 = iUTContext->iStrPool.OpenFStringL(KTxtUser);

   580 	CleanupClosePushL(stringVal2);

   581 	CHeaderFieldPart* part2 = CHeaderFieldPart::NewL(stringVal2);

   582 	CleanupStack::PushL(part2);

   583 	iUTContext->iTestHeader->SetPartL(part2, 1);

   584 	CleanupStack::Pop(part2);

   585 	CleanupStack::PopAndDestroy(&stringVal2);

   586 

   587 	// Part2

   588 	RStringF stringVal3 = iUTContext->iStrPool.OpenFStringL(KNullDesC8());

   589 	CleanupClosePushL(stringVal3);

   590 	CHeaderFieldPart* part3 = CHeaderFieldPart::NewL(stringVal3);

   591 	CleanupStack::PushL(part3);

   592 	iUTContext->iTestHeader->SetPartL(part3, 2);

   593 	CleanupStack::Pop(part3);

   594 	CleanupStack::PopAndDestroy(&stringVal3);

   595 

   596 	TBuf8<256> expectedBuf;

   597 	expectedBuf.Append(0x0B); // value-length for 11

   598 	expectedBuf.Append(0x80);

   599 	expectedBuf.Append(KTxtUser);

   600 	expectedBuf.Append(0x00);

   601 	expectedBuf.Append(0x00);

   602 	iUTContext->SetExpectedL(expectedBuf);

   603 

   604 	// Add the Transitions in the order they are to run

   605 	// C'tor first, D'tor last...

   606 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   607 		using constructor and destuctor validators */

   608 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   609 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   610 	iBasicNullPasswordValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   611 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iBasicNullPasswordValidator));

   612 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   613 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   614 	}

   615 

   616 // ______________________________________________________________________________

   617 //

   618 _LIT(KWspHeaderWriterBasicNullUserNullPassUnitTest,"CWspHeaderWriter_BasicNullUserNullPass_UnitTest");

   619 

   620 CWspHeaderWriter_BasicNullUserNullPass_UnitTest* CWspHeaderWriter_BasicNullUserNullPass_UnitTest::NewL(CDataLogger& aDataLogger,

   621 											MUnitTestObserver& aObserver)

   622 	{

   623 	CWspHeaderWriter_BasicNullUserNullPass_UnitTest* self = 

   624 					new(ELeave) CWspHeaderWriter_BasicNullUserNullPass_UnitTest(aDataLogger,

   625 																aObserver);

   626 	CleanupStack::PushL(self);

   627 	self->ConstructL();

   628 	CleanupStack::Pop(self);

   629 	return self; 

   630 	}

   631 

   632 inline TInt CWspHeaderWriter_BasicNullUserNullPass_UnitTest::RunError(TInt aError)

   633 	{

   634 	// The RunL left so chain to the base first and then cleanup

   635 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   636 	delete iUTContext;

   637 	iUTContext = NULL;

   638 	delete iStateAccessor;

   639 	iStateAccessor = NULL;

   640 	/* delete any validators used */

   641 	delete iCtorValidator;

   642 	iCtorValidator = NULL;

   643 	delete iBasicNullUserNullPassValidator;

   644 	iBasicNullUserNullPassValidator = NULL;

   645 	delete iDtorValidator;

   646 	iDtorValidator = NULL;

   647 	return error;

   648 	}

   649 

   650 inline CWspHeaderWriter_BasicNullUserNullPass_UnitTest::~CWspHeaderWriter_BasicNullUserNullPass_UnitTest()

   651 	{

   652 	// Simply delete our test class instance

   653 	delete iUTContext;

   654 	delete iStateAccessor;

   655 	/* delete any validators used */

   656 	delete iCtorValidator;

   657 	delete iBasicNullUserNullPassValidator;

   658 	delete iDtorValidator;

   659 	}

   660 

   661 inline CWspHeaderWriter_BasicNullUserNullPass_UnitTest::CWspHeaderWriter_BasicNullUserNullPass_UnitTest(CDataLogger& aDataLogger,

   662 																	MUnitTestObserver& aObserver)

   663 : CUnitTest(KWspHeaderWriterBasicNullUserNullPassUnitTest, aDataLogger, aObserver)

   664 	{

   665 	//Do nothing

   666 	}

   667 

   668 // Now the Individual transitions need to be added.

   669 inline void CWspHeaderWriter_BasicNullUserNullPass_UnitTest::ConstructL()

   670 	{

   671 	// Perform the base class initialization

   672 	UnitTestConstructL();

   673 

   674 	// Create the Unit test state accessor

   675 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   676 	// Construct the Unit test context.

   677 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   678 	iUTContext->ConstructL(WSP::EAuthorization);

   679 	

   680 	// Part1

   681 	_LIT8(KTxtBasic, "Basic");

   682 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtBasic);

   683 	CleanupClosePushL(stringVal);

   684 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   685 	CleanupStack::PushL(part1);

   686 	iUTContext->iTestHeader->SetPartL(part1, 0);

   687 	CleanupStack::Pop(part1);

   688 	CleanupStack::PopAndDestroy(&stringVal);

   689 

   690 	// Part2

   691 	RStringF stringVal2 = iUTContext->iStrPool.OpenFStringL(KNullDesC8());

   692 	CleanupClosePushL(stringVal2);

   693 	CHeaderFieldPart* part2 = CHeaderFieldPart::NewL(stringVal2);

   694 	CleanupStack::PushL(part2);

   695 	iUTContext->iTestHeader->SetPartL(part2, 1);

   696 	CleanupStack::Pop(part2);

   697 	CleanupStack::PopAndDestroy(&stringVal2);

   698 

   699 	// Part2

   700 	RStringF stringVal3 = iUTContext->iStrPool.OpenFStringL(KNullDesC8());

   701 	CleanupClosePushL(stringVal3);

   702 	CHeaderFieldPart* part3 = CHeaderFieldPart::NewL(stringVal3);

   703 	CleanupStack::PushL(part3);

   704 	iUTContext->iTestHeader->SetPartL(part3, 2);

   705 	CleanupStack::Pop(part3);

   706 	CleanupStack::PopAndDestroy(&stringVal3);

   707 

   708 	TBuf8<256> expectedBuf;

   709 	expectedBuf.Append(0x03); // value-length for 3

   710 	expectedBuf.Append(0x80);

   711 	expectedBuf.Append(0x00);

   712 	expectedBuf.Append(0x00);

   713 	iUTContext->SetExpectedL(expectedBuf);

   714 

   715 	// Add the Transitions in the order they are to run

   716 	// C'tor first, D'tor last...

   717 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   718 		using constructor and destuctor validators */

   719 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   720 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   721 	iBasicNullUserNullPassValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   722 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iBasicNullUserNullPassValidator));

   723 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   724 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   725 	}

   726 

   727 // ______________________________________________________________________________

   728 //

   729 _LIT(KWspHeaderWriterAuthorizationSchemeNoParamUnitTest,"CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest");

   730 

   731 CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest* CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest::NewL(CDataLogger& aDataLogger,

   732 											MUnitTestObserver& aObserver)

   733 	{

   734 	CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest* self = 

   735 					new(ELeave) CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest(aDataLogger,

   736 																aObserver);

   737 	CleanupStack::PushL(self);

   738 	self->ConstructL();

   739 	CleanupStack::Pop(self);

   740 	return self; 

   741 	}

   742 

   743 inline TInt CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest::RunError(TInt aError)

   744 	{

   745 	// The RunL left so chain to the base first and then cleanup

   746 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   747 	delete iUTContext;

   748 	iUTContext = NULL;

   749 	delete iStateAccessor;

   750 	iStateAccessor = NULL;

   751 	/* delete any validators used */

   752 	delete iCtorValidator;

   753 	iCtorValidator = NULL;

   754 	delete iAuthorizationSchemeNoParamValidator;

   755 	iAuthorizationSchemeNoParamValidator = NULL;

   756 	delete iDtorValidator;

   757 	iDtorValidator = NULL;

   758 	return error;

   759 	}

   760 

   761 inline CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest::~CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest()

   762 	{

   763 	// Simply delete our test class instance

   764 	delete iUTContext;

   765 	delete iStateAccessor;

   766 	/* delete any validators used */

   767 	delete iCtorValidator;

   768 	delete iAuthorizationSchemeNoParamValidator;

   769 	delete iDtorValidator;

   770 	}

   771 

   772 inline CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest::CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest(CDataLogger& aDataLogger,

   773 																	MUnitTestObserver& aObserver)

   774 : CUnitTest(KWspHeaderWriterAuthorizationSchemeNoParamUnitTest, aDataLogger, aObserver)

   775 	{

   776 	//Do nothing

   777 	}

   778 

   779 // Now the Individual transitions need to be added.

   780 inline void CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest::ConstructL()

   781 	{

   782 	// Perform the base class initialization

   783 	UnitTestConstructL();

   784 

   785 	// Create the Unit test state accessor

   786 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   787 	// Construct the Unit test context.

   788 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   789 	iUTContext->ConstructL(WSP::EAuthorization);

   790 	

   791 	// Part1

   792 	_LIT8(KTxtScheme, "authscheme");

   793 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtScheme);

   794 	CleanupClosePushL(stringVal);

   795 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   796 	CleanupStack::PushL(part1);

   797 	iUTContext->iTestHeader->SetPartL(part1, 0);

   798 	CleanupStack::Pop(part1);

   799 	CleanupStack::PopAndDestroy(&stringVal);

   800 

   801 	TBuf8<256> expectedBuf;

   802 	expectedBuf.Append(0x0B); // value-length for 11

   803 	expectedBuf.Append(KTxtScheme);

   804 	expectedBuf.Append(0x00);

   805 	iUTContext->SetExpectedL(expectedBuf);

   806 

   807 	// Add the Transitions in the order they are to run

   808 	// C'tor first, D'tor last...

   809 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   810 		using constructor and destuctor validators */

   811 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   812 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   813 	iAuthorizationSchemeNoParamValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   814 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iAuthorizationSchemeNoParamValidator));

   815 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   816 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   817 	}

   818 

   819 // ______________________________________________________________________________

   820 //

   821 _LIT(KWspHeaderWriterAuthorizationInvalidSchemeTokenUnitTest,"CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest");

   822 

   823 CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest* CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest::NewL(CDataLogger& aDataLogger,

   824 											MUnitTestObserver& aObserver)

   825 	{

   826 	CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest* self = 

   827 					new(ELeave) CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest(aDataLogger,

   828 																aObserver);

   829 	CleanupStack::PushL(self);

   830 	self->ConstructL();

   831 	CleanupStack::Pop(self);

   832 	return self; 

   833 	}

   834 

   835 inline TInt CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest::RunError(TInt aError)

   836 	{

   837 	// The RunL left so chain to the base first and then cleanup

   838 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   839 	delete iUTContext;

   840 	iUTContext = NULL;

   841 	delete iStateAccessor;

   842 	iStateAccessor = NULL;

   843 	/* delete any validators used */

   844 	delete iCtorValidator;

   845 	iCtorValidator = NULL;

   846 	delete iAuthorizationInvalidSchemeTokenValidator;

   847 	iAuthorizationInvalidSchemeTokenValidator = NULL;

   848 	delete iDtorValidator;

   849 	iDtorValidator = NULL;

   850 	return error;

   851 	}

   852 

   853 inline CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest::~CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest()

   854 	{

   855 	// Simply delete our test class instance

   856 	delete iUTContext;

   857 	delete iStateAccessor;

   858 	/* delete any validators used */

   859 	delete iCtorValidator;

   860 	delete iAuthorizationInvalidSchemeTokenValidator;

   861 	delete iDtorValidator;

   862 	}

   863 

   864 inline CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest::CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest(CDataLogger& aDataLogger,

   865 																	MUnitTestObserver& aObserver)

   866 : CUnitTest(KWspHeaderWriterAuthorizationInvalidSchemeTokenUnitTest, aDataLogger, aObserver)

   867 	{

   868 	//Do nothing

   869 	}

   870 

   871 // Now the Individual transitions need to be added.

   872 inline void CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest::ConstructL()

   873 	{

   874 	// Perform the base class initialization

   875 	UnitTestConstructL();

   876 

   877 	// Create the Unit test state accessor

   878 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   879 	// Construct the Unit test context.

   880 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   881 	iUTContext->ConstructL(WSP::EAuthorization);

   882 	

   883 	// Part1

   884 	_LIT8(KTxtScheme, "auth@scheme");

   885 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtScheme);

   886 	CleanupClosePushL(stringVal);

   887 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   888 	CleanupStack::PushL(part1);

   889 	iUTContext->iTestHeader->SetPartL(part1, 0);

   890 	CleanupStack::Pop(part1);

   891 	CleanupStack::PopAndDestroy(&stringVal);

   892 

   893 	TBuf8<256> expectedBuf;

   894 	_LIT8(KTxtExpected, "-20");

   895 	expectedBuf.Append(KTxtExpected);

   896 	iUTContext->SetExpectedL(expectedBuf);

   897 

   898 	// Add the Transitions in the order they are to run

   899 	// C'tor first, D'tor last...

   900 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

   901 		using constructor and destuctor validators */

   902 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

   903 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

   904 	iAuthorizationInvalidSchemeTokenValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

   905 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderLTrap_Transition(*iUTContext,*iAuthorizationInvalidSchemeTokenValidator));

   906 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

   907 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

   908 	}

   909 

   910 // ______________________________________________________________________________

   911 //

   912 _LIT(KWspHeaderWriterAuthorizationScheme2ParamsUnitTest,"CWspHeaderWriter_AuthorizationScheme2Params_UnitTest");

   913 

   914 CWspHeaderWriter_AuthorizationScheme2Params_UnitTest* CWspHeaderWriter_AuthorizationScheme2Params_UnitTest::NewL(CDataLogger& aDataLogger,

   915 											MUnitTestObserver& aObserver)

   916 	{

   917 	CWspHeaderWriter_AuthorizationScheme2Params_UnitTest* self = 

   918 					new(ELeave) CWspHeaderWriter_AuthorizationScheme2Params_UnitTest(aDataLogger,

   919 																aObserver);

   920 	CleanupStack::PushL(self);

   921 	self->ConstructL();

   922 	CleanupStack::Pop(self);

   923 	return self; 

   924 	}

   925 

   926 inline TInt CWspHeaderWriter_AuthorizationScheme2Params_UnitTest::RunError(TInt aError)

   927 	{

   928 	// The RunL left so chain to the base first and then cleanup

   929 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   930 	delete iUTContext;

   931 	iUTContext = NULL;

   932 	delete iStateAccessor;

   933 	iStateAccessor = NULL;

   934 	/* delete any validators used */

   935 	delete iCtorValidator;

   936 	iCtorValidator = NULL;

   937 	delete iAuthorizationScheme2ParamsValidator;

   938 	iAuthorizationScheme2ParamsValidator = NULL;

   939 	delete iDtorValidator;

   940 	iDtorValidator = NULL;

   941 	return error;

   942 	}

   943 

   944 inline CWspHeaderWriter_AuthorizationScheme2Params_UnitTest::~CWspHeaderWriter_AuthorizationScheme2Params_UnitTest()

   945 	{

   946 	// Simply delete our test class instance

   947 	delete iUTContext;

   948 	delete iStateAccessor;

   949 	/* delete any validators used */

   950 	delete iCtorValidator;

   951 	delete iAuthorizationScheme2ParamsValidator;

   952 	delete iDtorValidator;

   953 	}

   954 

   955 inline CWspHeaderWriter_AuthorizationScheme2Params_UnitTest::CWspHeaderWriter_AuthorizationScheme2Params_UnitTest(CDataLogger& aDataLogger,

   956 																	MUnitTestObserver& aObserver)

   957 : CUnitTest(KWspHeaderWriterAuthorizationScheme2ParamsUnitTest, aDataLogger, aObserver)

   958 	{

   959 	//Do nothing

   960 	}

   961 

   962 // Now the Individual transitions need to be added.

   963 inline void CWspHeaderWriter_AuthorizationScheme2Params_UnitTest::ConstructL()

   964 	{

   965 	// Perform the base class initialization

   966 	UnitTestConstructL();

   967 

   968 	// Create the Unit test state accessor

   969 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

   970 	// Construct the Unit test context.

   971 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   972 	iUTContext->ConstructL(WSP::EAuthorization);

   973 	

   974 	// Part1

   975 	_LIT8(KTxtScheme, "authscheme");

   976 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtScheme);

   977 	CleanupClosePushL(stringVal);

   978 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

   979 	CleanupStack::PushL(part1);

   980 

   981 	// Param1

   982 	_LIT8(KTxtParam1Name, "Name");

   983 	_LIT8(KTxtParam1Value, "myname");

   984 	RStringF paramName1 = iUTContext->iStrPool.OpenFStringL(KTxtParam1Name);

   985 	CleanupClosePushL(paramName1);

   986 	RStringF paramValueStr1 = iUTContext->iStrPool.OpenFStringL(KTxtParam1Value);

   987 	CleanupClosePushL(paramValueStr1);

   988 	THTTPHdrVal paramValue1(paramValueStr1);

   989 	CHeaderFieldParam* param1 = CHeaderFieldParam::NewL(paramName1, paramValue1);

   990 	CleanupStack::PushL(param1);

   991 	part1->AddParamL(param1);

   992 	CleanupStack::Pop(param1);

   993 

   994 	// Param2

   995 	_LIT8(KTxtParam2Name, "Q");

   996 	_LIT8(KTxtParam2Value, "0.333");

   997 	RStringF paramName2 = iUTContext->iStrPool.OpenFStringL(KTxtParam2Name);

   998 	CleanupClosePushL(paramName2);

   999 	RStringF paramValueStr2 = iUTContext->iStrPool.OpenFStringL(KTxtParam2Value);

  1000 	CleanupClosePushL(paramValueStr2);

  1001 	THTTPHdrVal paramValue2(paramValueStr2);

  1002 	CHeaderFieldParam* param2 = CHeaderFieldParam::NewL(paramName2, paramValue2);

  1003 	CleanupStack::PushL(param2);

  1004 	part1->AddParamL(param2);

  1005 	CleanupStack::Pop(param2);

  1006 

  1007 	iUTContext->iTestHeader->SetPartL(part1, 0);

  1008 	CleanupStack::PopAndDestroy(4, &paramName1);

  1009 	CleanupStack::Pop(part1);

  1010 	CleanupStack::PopAndDestroy(&stringVal);

  1011 

  1012 	TBuf8<256> expectedBuf;

  1013 	expectedBuf.Append(0x16); // value length for 22

  1014 	expectedBuf.Append(KTxtScheme);

  1015 	expectedBuf.Append(0x00);

  1016 	expectedBuf.Append(0x97); // token for param1 "Name" using encoding version 1.4

  1017 	expectedBuf.Append(KTxtParam1Value);

  1018 	expectedBuf.Append(0x00);

  1019 	expectedBuf.Append(0x80); // token for param2 "Q"

  1020 	expectedBuf.Append(0x83); // encoding for 0.333...

  1021 	expectedBuf.Append(0x31); // ...

  1022 	iUTContext->SetExpectedL(expectedBuf);

  1023 

  1024 	// Add the Transitions in the order they are to run

  1025 	// C'tor first, D'tor last...

  1026 	/*	Examples of C'tor and D'tor transitions on CWspHeaderWriter class.

  1027 		using constructor and destuctor validators */

  1028 	iCtorValidator = new(ELeave) TWspHeaderWriter_Ctor_TransitionValidator(*iUTContext);

  1029 	AddTransitionL(new(ELeave)CWspHeaderWriter_NewL_Transition(*iUTContext,*iCtorValidator));

  1030 	iAuthorizationScheme2ParamsValidator = new(ELeave) TWspHeaderWriter_EncodeHeaderL_TransitionValidator(*iUTContext);

  1031 	AddTransitionL(new(ELeave)CWspHeaderWriter_EncodeHeaderL_Transition(*iUTContext,*iAuthorizationScheme2ParamsValidator));

  1032 	iDtorValidator = new(ELeave) TWspHeaderWriter_Dtor_TransitionValidator(*iUTContext);

  1033 	AddTransitionL(new(ELeave)CWspHeaderWriter_Dtor_Transition(*iUTContext,*iDtorValidator));

  1034 	}

  1035 

  1036 // ______________________________________________________________________________

  1037 //

  1038 _LIT(KWspHeaderWriterAuthorizationScheme2ParamV1_2UnitTest,"CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest");

  1039 

  1040 CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest* CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest::NewL(CDataLogger& aDataLogger,

  1041 											MUnitTestObserver& aObserver)

  1042 	{

  1043 	CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest* self = 

  1044 					new(ELeave) CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest(aDataLogger,

  1045 																aObserver);

  1046 	CleanupStack::PushL(self);

  1047 	self->ConstructL();

  1048 	CleanupStack::Pop(self);

  1049 	return self; 

  1050 	}

  1051 

  1052 inline TInt CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest::RunError(TInt aError)

  1053 	{

  1054 	// The RunL left so chain to the base first and then cleanup

  1055 	TInt error = CUnitTest::RunError(aError);	// Chain to base

  1056 	delete iUTContext;

  1057 	iUTContext = NULL;

  1058 	delete iStateAccessor;

  1059 	iStateAccessor = NULL;

  1060 	/* delete any validators used */

  1061 	delete iCtorValidator;

  1062 	iCtorValidator = NULL;

  1063 	delete iAuthorizationScheme2ParamV1_2Validator;

  1064 	iAuthorizationScheme2ParamV1_2Validator = NULL;

  1065 	delete iDtorValidator;

  1066 	iDtorValidator = NULL;

  1067 	return error;

  1068 	}

  1069 

  1070 inline CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest::~CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest()

  1071 	{

  1072 	// Simply delete our test class instance

  1073 	delete iUTContext;

  1074 	delete iStateAccessor;

  1075 	/* delete any validators used */

  1076 	delete iCtorValidator;

  1077 	delete iAuthorizationScheme2ParamV1_2Validator;

  1078 	delete iDtorValidator;

  1079 	}

  1080 

  1081 inline CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest::CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest(CDataLogger& aDataLogger,

  1082 																	MUnitTestObserver& aObserver)

  1083 : CUnitTest(KWspHeaderWriterAuthorizationScheme2ParamV1_2UnitTest, aDataLogger, aObserver)

  1084 	{

  1085 	//Do nothing

  1086 	}

  1087 

  1088 // Now the Individual transitions need to be added.

  1089 inline void CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest::ConstructL()

  1090 	{

  1091 	// Perform the base class initialization

  1092 	UnitTestConstructL();

  1093 

  1094 	// Create the Unit test state accessor

  1095 	iStateAccessor = new(ELeave) TWspHeaderWriter_StateAccessor;

  1096 	// Construct the Unit test context.

  1097 	iUTContext = new(ELeave) CWspHeaderWriter_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

  1098 	iUTContext->ConstructL(WSP::EAuthorization);

  1099 	(REINTERPRET_CAST(CWspHeaderCodec*, iUTContext->iCodec))->SetWspVersion(CWspHeaderCodec::EVersion1_2);

  1100 	

  1101 	// Part1

  1102 	_LIT8(KTxtScheme, "authscheme");

  1103 	RStringF stringVal = iUTContext->iStrPool.OpenFStringL(KTxtScheme);

  1104 	CleanupClosePushL(stringVal);

  1105 	CHeaderFieldPart* part1 = CHeaderFieldPart::NewL(stringVal);

  1106 	CleanupStack::PushL(part1);

  1107 

  1108 	// Param1

  1109 	_LIT8(KTxtParam1Name, "Name");

  1110 	_LIT8(KTxtParam1Value, "myname");

  1111 	RStringF paramName1 = iUTContext->iStrPool.OpenFStringL(KTxtParam1Name);

  1112 	CleanupClosePushL(paramName1);

  1113 	RStringF paramValueStr1 = iUTContext->iStrPool.OpenFStringL(KTxtParam1Value);

  1114 	CleanupClosePushL(paramValueStr1);

  1115 	THTTPHdrVal paramValue1(paramValueStr1);

  1116 	CHeaderFieldParam* param1 = CHeaderFieldParam::NewL(paramName1, paramValue1);

  1117 	CleanupStack::PushL(param1);

  1118 	part1->AddParamL(param1);

  1119 	CleanupStack::Pop(param1);

  1120 

  1121 	// Param2

  1122 	_LIT8(KTxtParam2Name, "Q");

  1123 	_LIT8(KTxtParam2Value, "0.333");

  1124 	RStringF paramName2 = iUTContext->iStrPool.OpenFStringL(KTxtParam2Name);

  1125 	CleanupClosePushL(paramName2);

  1126 	RStringF paramValueStr2 = iUTContext->iStrPool.OpenFStringL(KTxtParam2Value);

  1127 	CleanupClosePushL(paramValueStr2);

  1128 	THTTPHdrVal paramValue2(paramValueStr2);

  1129 	CHeaderFieldParam* param2 = CHeaderFieldParam::NewL(paramName2, paramValue2);

  1130 	CleanupStack::PushL(param2);

  1131 	part1->AddParamL(param2);

  1132 	CleanupStack::Pop(param2);

  1133 

  1134 	iUTContext->iTestHeader->SetPartL(part1, 0);

  1135 	CleanupStack::PopAndDestroy(4, &paramName1);