1 // Copyright (c) 2001-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 // The unit test class definitions for the CWspHeaderWriter class.

    15 // 

    16 //

    17 

    18 /**

    19  @file WspHeaderWriterUnitTest.h

    20 */

    21 #ifndef __WSPHEADERWRITERUNITTEST_H__

    22 #define __WSPHEADERWRITERUNITTEST_H__

    23 

    24 #include "TestBedDefinitions.h"

    25 #include "WspHeaderWriterStateAccessor.h"

    26 #include "WspHeaderWriterTransitionValidation.h"

    27 #include "WspHeaderWriterTransitions.h"

    28 

    29 // ______________________________________________________________________________

    30 //

    31 /**

    32 	@internal

    33 	@class CWspHeaderWriter_CreateAndDestroy_UnitTest

    34 	@Depends CWspHeaderWriter & CUnitTest 

    35 

    36 	Comments : Unit Test for CreateAndDestroy on CWspHeaderWriter, the class under test.

    37  */

    38 class CWspHeaderWriter_CreateAndDestroy_UnitTest : public CUnitTest

    39 	{

    40 public:

    41 	/**

    42 		@fn				NewL(CDataLogger& aDataLogger,

    43 							MUnitTestObserver& aObserver)

    44 		Intended Usage	: Standard two-phase construction which leaves nothing on the

    45 						cleanup stack.

    46 		Error Condition	: Leaves with the error code.

    47 		@exceptions		KErrNoMemory

    48 		@since			7.0

    49 		@param			aDataLogger The output logging object.

    50 		@param			aObserver The observer of this UnitTest.

    51 		@return			CWspHeaderWriter_CreateAndDestroy_UnitTest* The constructed object.

    52 		@pre 			None.

    53 		@post			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully constructed, and initialized.

    54 	 */

    55 	static CWspHeaderWriter_CreateAndDestroy_UnitTest* NewL(CDataLogger& aDataLogger,

    56 											MUnitTestObserver& aObserver);

    57 

    58 	/**

    59 		@fn				RunError(TInt aError)

    60 		Intended Usage	: Intercept the panic caused by a RunL leave,

    61 						to restore the CWspHeaderWriter_CreateAndDestroy_UnitTest

    62 						object to a sensible state.

    63 						(called by the Active Scheduler immediately before the Panic).

    64 		Error Condition	: @see CUnitTest::RunError().

    65 		@since			7.0

    66 		@return			KErrNone if cleanup successful, otherwise

    67 						@see CUnitTest::RunError()

    68 		@pre 			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully constructed, and initialized.

    69 		@post			The object has been restored to a sensible state.

    70 	 */

    71 	inline TInt RunError(TInt aError);

    72 

    73 	/**

    74 		@fn				~CWspHeaderWriter_CreateAndDestroy_UnitTest()

    75 		Intended Usage	: Standard Destructor.

    76 		Error Condition	: None.	

    77 		@since			7.0

    78 		@pre 			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully constructed.

    79 		@post			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully destroyed.

    80 	*/

    81 	~CWspHeaderWriter_CreateAndDestroy_UnitTest();

    82 

    83 private:

    84 	/**

    85 		@fn				CWspHeaderWriter_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    86 														MUnitTestObserver& aObserver)

    87 		Intended Usage	: Default constructor.

    88 		Error Condition	: None. 

    89 		@since			7.0

    90 		@param			aDataLogger The output logging object.

    91 		@param			aObserver The observer of this UnitTest.

    92 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

    93 		@pre 			None.

    94 		@post			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully constructed.

    95 	*/

    96 	inline CWspHeaderWriter_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    97 											MUnitTestObserver& aObserver);

    98 

    99 	/**

   100 		@fn				void ConstructL()

   101 		Intended Usage	: Second phase of safe two phase construction, 

   102 		to complete the object initialisation.

   103 		Error Condition	: Leaves with an error code.

   104 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   105 		@since			7.0

   106 		@return			None 

   107 		@pre 			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully constructed.

   108 		@post			CWspHeaderWriter_CreateAndDestroy_UnitTest is fully initialized.

   109 	*/

   110 	void ConstructL();

   111 

   112 	/**

   113 	The context of the Unit Test.

   114 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   115 	 */

   116 	CWspHeaderWriter_UnitTestContext* iUTContext;

   117 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   118 	/* C'tor, d'tor, and method transition validators */

   119 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   120 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   121 	};	// CWspHeaderWriter_CreateAndDestroy_UnitTest

   122 

   123 // ______________________________________________________________________________

   124 //

   125 /**

   126 	@internal

   127 	@class CWspHeaderWriter_UserAgent_UnitTest

   128 	@Depends CWspHeaderWriter & CUnitTest 

   129 

   130 	Comments : Unit Test for UserAgent on CWspHeaderWriter, the class under test.

   131  */

   132 class CWspHeaderWriter_UserAgent_UnitTest : public CUnitTest

   133 	{

   134 public:

   135 	/**

   136 		@fn				NewL(CDataLogger& aDataLogger,

   137 							MUnitTestObserver& aObserver)

   138 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   139 						cleanup stack.

   140 		Error Condition	: Leaves with the error code.

   141 		@exceptions		KErrNoMemory

   142 		@since			7.0

   143 		@param			aDataLogger The output logging object.

   144 		@param			aObserver The observer of this UnitTest.

   145 		@return			CWspHeaderWriter_UserAgent_UnitTest* The constructed object.

   146 		@pre 			None.

   147 		@post			CWspHeaderWriter_UserAgent_UnitTest is fully constructed, and initialized.

   148 	 */

   149 	static CWspHeaderWriter_UserAgent_UnitTest* NewL(CDataLogger& aDataLogger,

   150 											MUnitTestObserver& aObserver);

   151 

   152 	/**

   153 		@fn				RunError(TInt aError)

   154 		Intended Usage	: Intercept the panic caused by a RunL leave,

   155 						to restore the CWspHeaderWriter_UserAgent_UnitTest

   156 						object to a sensible state.

   157 						(called by the Active Scheduler immediately before the Panic).

   158 		Error Condition	: @see CUnitTest::RunError().

   159 		@since			7.0

   160 		@return			KErrNone if cleanup successful, otherwise

   161 						@see CUnitTest::RunError()

   162 		@pre 			CWspHeaderWriter_UserAgent_UnitTest is fully constructed, and initialized.

   163 		@post			The object has been restored to a sensible state.

   164 	 */

   165 	inline TInt RunError(TInt aError);

   166 

   167 	/**

   168 		@fn				~CWspHeaderWriter_UserAgent_UnitTest()

   169 		Intended Usage	: Standard Destructor.

   170 		Error Condition	: None.	

   171 		@since			7.0

   172 		@pre 			CWspHeaderWriter_UserAgent_UnitTest is fully constructed.

   173 		@post			CWspHeaderWriter_UserAgent_UnitTest is fully destroyed.

   174 	*/

   175 	~CWspHeaderWriter_UserAgent_UnitTest();

   176 

   177 private:

   178 	/**

   179 		@fn				CWspHeaderWriter_UserAgent_UnitTest(CDataLogger& aDataLogger,

   180 														MUnitTestObserver& aObserver)

   181 		Intended Usage	: Default constructor.

   182 		Error Condition	: None. 

   183 		@since			7.0

   184 		@param			aDataLogger The output logging object.

   185 		@param			aObserver The observer of this UnitTest.

   186 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   187 		@pre 			None.

   188 		@post			CWspHeaderWriter_UserAgent_UnitTest is fully constructed.

   189 	*/

   190 	inline CWspHeaderWriter_UserAgent_UnitTest(CDataLogger& aDataLogger,

   191 											MUnitTestObserver& aObserver);

   192 

   193 	/**

   194 		@fn				void ConstructL()

   195 		Intended Usage	: Second phase of safe two phase construction, 

   196 		to complete the object initialisation.

   197 		Error Condition	: Leaves with an error code.

   198 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   199 		@since			7.0

   200 		@return			None 

   201 		@pre 			CWspHeaderWriter_UserAgent_UnitTest is fully constructed.

   202 		@post			CWspHeaderWriter_UserAgent_UnitTest is fully initialized.

   203 	*/

   204 	void ConstructL();

   205 

   206 	/**

   207 	The context of the Unit Test.

   208 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   209 	 */

   210 	CWspHeaderWriter_UnitTestContext* iUTContext;

   211 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   212 	/* C'tor, d'tor, and method transition validators */

   213 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   214 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iUserAgentValidator;

   215 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   216 	};	// CWspHeaderWriter_UserAgent_UnitTest

   217 

   218 // ______________________________________________________________________________

   219 //

   220 /**

   221 	@internal

   222 	@class CWspHeaderWriter_UserAgentNullText_UnitTest

   223 	@Depends CWspHeaderWriter & CUnitTest 

   224 

   225 	Comments : Unit Test for UserAgentNullText on CWspHeaderWriter, the class under test.

   226  */

   227 class CWspHeaderWriter_UserAgentNullText_UnitTest : public CUnitTest

   228 	{

   229 public:

   230 	/**

   231 		@fn				NewL(CDataLogger& aDataLogger,

   232 							MUnitTestObserver& aObserver)

   233 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   234 						cleanup stack.

   235 		Error Condition	: Leaves with the error code.

   236 		@exceptions		KErrNoMemory

   237 		@since			7.0

   238 		@param			aDataLogger The output logging object.

   239 		@param			aObserver The observer of this UnitTest.

   240 		@return			CWspHeaderWriter_UserAgentNullText_UnitTest* The constructed object.

   241 		@pre 			None.

   242 		@post			CWspHeaderWriter_UserAgentNullText_UnitTest is fully constructed, and initialized.

   243 	 */

   244 	static CWspHeaderWriter_UserAgentNullText_UnitTest* NewL(CDataLogger& aDataLogger,

   245 											MUnitTestObserver& aObserver);

   246 

   247 	/**

   248 		@fn				RunError(TInt aError)

   249 		Intended Usage	: Intercept the panic caused by a RunL leave,

   250 						to restore the CWspHeaderWriter_UserAgentNullText_UnitTest

   251 						object to a sensible state.

   252 						(called by the Active Scheduler immediately before the Panic).

   253 		Error Condition	: @see CUnitTest::RunError().

   254 		@since			7.0

   255 		@return			KErrNone if cleanup successful, otherwise

   256 						@see CUnitTest::RunError()

   257 		@pre 			CWspHeaderWriter_UserAgentNullText_UnitTest is fully constructed, and initialized.

   258 		@post			The object has been restored to a sensible state.

   259 	 */

   260 	inline TInt RunError(TInt aError);

   261 

   262 	/**

   263 		@fn				~CWspHeaderWriter_UserAgentNullText_UnitTest()

   264 		Intended Usage	: Standard Destructor.

   265 		Error Condition	: None.	

   266 		@since			7.0

   267 		@pre 			CWspHeaderWriter_UserAgentNullText_UnitTest is fully constructed.

   268 		@post			CWspHeaderWriter_UserAgentNullText_UnitTest is fully destroyed.

   269 	*/

   270 	~CWspHeaderWriter_UserAgentNullText_UnitTest();

   271 

   272 private:

   273 	/**

   274 		@fn				CWspHeaderWriter_UserAgentNullText_UnitTest(CDataLogger& aDataLogger,

   275 														MUnitTestObserver& aObserver)

   276 		Intended Usage	: Default constructor.

   277 		Error Condition	: None. 

   278 		@since			7.0

   279 		@param			aDataLogger The output logging object.

   280 		@param			aObserver The observer of this UnitTest.

   281 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   282 		@pre 			None.

   283 		@post			CWspHeaderWriter_UserAgentNullText_UnitTest is fully constructed.

   284 	*/

   285 	inline CWspHeaderWriter_UserAgentNullText_UnitTest(CDataLogger& aDataLogger,

   286 											MUnitTestObserver& aObserver);

   287 

   288 	/**

   289 		@fn				void ConstructL()

   290 		Intended Usage	: Second phase of safe two phase construction, 

   291 		to complete the object initialisation.

   292 		Error Condition	: Leaves with an error code.

   293 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   294 		@since			7.0

   295 		@return			None 

   296 		@pre 			CWspHeaderWriter_UserAgentNullText_UnitTest is fully constructed.

   297 		@post			CWspHeaderWriter_UserAgentNullText_UnitTest is fully initialized.

   298 	*/

   299 	void ConstructL();

   300 

   301 	/**

   302 	The context of the Unit Test.

   303 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   304 	 */

   305 	CWspHeaderWriter_UnitTestContext* iUTContext;

   306 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   307 	/* C'tor, d'tor, and method transition validators */

   308 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   309 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iUserAgentNullTextValidator;

   310 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   311 	};	// CWspHeaderWriter_UserAgentNullText_UnitTest

   312 

   313 // ______________________________________________________________________________

   314 //

   315 /**

   316 	@internal

   317 	@class CWspHeaderWriter_AuthorizationBasic_UnitTest

   318 	@Depends CWspHeaderWriter & CUnitTest 

   319 

   320 	Comments : Unit Test for AuthorizationBasic on CWspHeaderWriter, the class under test.

   321  */

   322 class CWspHeaderWriter_AuthorizationBasic_UnitTest : public CUnitTest

   323 	{

   324 public:

   325 	/**

   326 		@fn				NewL(CDataLogger& aDataLogger,

   327 							MUnitTestObserver& aObserver)

   328 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   329 						cleanup stack.

   330 		Error Condition	: Leaves with the error code.

   331 		@exceptions		KErrNoMemory

   332 		@since			7.0

   333 		@param			aDataLogger The output logging object.

   334 		@param			aObserver The observer of this UnitTest.

   335 		@return			CWspHeaderWriter_AuthorizationBasic_UnitTest* The constructed object.

   336 		@pre 			None.

   337 		@post			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully constructed, and initialized.

   338 	 */

   339 	static CWspHeaderWriter_AuthorizationBasic_UnitTest* NewL(CDataLogger& aDataLogger,

   340 											MUnitTestObserver& aObserver);

   341 

   342 	/**

   343 		@fn				RunError(TInt aError)

   344 		Intended Usage	: Intercept the panic caused by a RunL leave,

   345 						to restore the CWspHeaderWriter_AuthorizationBasic_UnitTest

   346 						object to a sensible state.

   347 						(called by the Active Scheduler immediately before the Panic).

   348 		Error Condition	: @see CUnitTest::RunError().

   349 		@since			7.0

   350 		@return			KErrNone if cleanup successful, otherwise

   351 						@see CUnitTest::RunError()

   352 		@pre 			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully constructed, and initialized.

   353 		@post			The object has been restored to a sensible state.

   354 	 */

   355 	inline TInt RunError(TInt aError);

   356 

   357 	/**

   358 		@fn				~CWspHeaderWriter_AuthorizationBasic_UnitTest()

   359 		Intended Usage	: Standard Destructor.

   360 		Error Condition	: None.	

   361 		@since			7.0

   362 		@pre 			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully constructed.

   363 		@post			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully destroyed.

   364 	*/

   365 	~CWspHeaderWriter_AuthorizationBasic_UnitTest();

   366 

   367 private:

   368 	/**

   369 		@fn				CWspHeaderWriter_AuthorizationBasic_UnitTest(CDataLogger& aDataLogger,

   370 														MUnitTestObserver& aObserver)

   371 		Intended Usage	: Default constructor.

   372 		Error Condition	: None. 

   373 		@since			7.0

   374 		@param			aDataLogger The output logging object.

   375 		@param			aObserver The observer of this UnitTest.

   376 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   377 		@pre 			None.

   378 		@post			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully constructed.

   379 	*/

   380 	inline CWspHeaderWriter_AuthorizationBasic_UnitTest(CDataLogger& aDataLogger,

   381 											MUnitTestObserver& aObserver);

   382 

   383 	/**

   384 		@fn				void ConstructL()

   385 		Intended Usage	: Second phase of safe two phase construction, 

   386 		to complete the object initialisation.

   387 		Error Condition	: Leaves with an error code.

   388 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   389 		@since			7.0

   390 		@return			None 

   391 		@pre 			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully constructed.

   392 		@post			CWspHeaderWriter_AuthorizationBasic_UnitTest is fully initialized.

   393 	*/

   394 	void ConstructL();

   395 

   396 	/**

   397 	The context of the Unit Test.

   398 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   399 	 */

   400 	CWspHeaderWriter_UnitTestContext* iUTContext;

   401 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   402 	/* C'tor, d'tor, and method transition validators */

   403 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   404 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iAuthorizationBasicValidator;

   405 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   406 	};	// CWspHeaderWriter_AuthorizationBasic_UnitTest

   407 

   408 // ______________________________________________________________________________

   409 //

   410 /**

   411 	@internal

   412 	@class CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest

   413 	@Depends CWspHeaderWriter & CUnitTest 

   414 

   415 	Comments : Unit Test for AuthorizationBasicNullUser on CWspHeaderWriter, the class under test.

   416  */

   417 class CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest : public CUnitTest

   418 	{

   419 public:

   420 	/**

   421 		@fn				NewL(CDataLogger& aDataLogger,

   422 							MUnitTestObserver& aObserver)

   423 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   424 						cleanup stack.

   425 		Error Condition	: Leaves with the error code.

   426 		@exceptions		KErrNoMemory

   427 		@since			7.0

   428 		@param			aDataLogger The output logging object.

   429 		@param			aObserver The observer of this UnitTest.

   430 		@return			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest* The constructed object.

   431 		@pre 			None.

   432 		@post			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully constructed, and initialized.

   433 	 */

   434 	static CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest* NewL(CDataLogger& aDataLogger,

   435 											MUnitTestObserver& aObserver);

   436 

   437 	/**

   438 		@fn				RunError(TInt aError)

   439 		Intended Usage	: Intercept the panic caused by a RunL leave,

   440 						to restore the CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest

   441 						object to a sensible state.

   442 						(called by the Active Scheduler immediately before the Panic).

   443 		Error Condition	: @see CUnitTest::RunError().

   444 		@since			7.0

   445 		@return			KErrNone if cleanup successful, otherwise

   446 						@see CUnitTest::RunError()

   447 		@pre 			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully constructed, and initialized.

   448 		@post			The object has been restored to a sensible state.

   449 	 */

   450 	inline TInt RunError(TInt aError);

   451 

   452 	/**

   453 		@fn				~CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest()

   454 		Intended Usage	: Standard Destructor.

   455 		Error Condition	: None.	

   456 		@since			7.0

   457 		@pre 			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully constructed.

   458 		@post			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully destroyed.

   459 	*/

   460 	~CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest();

   461 

   462 private:

   463 	/**

   464 		@fn				CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest(CDataLogger& aDataLogger,

   465 														MUnitTestObserver& aObserver)

   466 		Intended Usage	: Default constructor.

   467 		Error Condition	: None. 

   468 		@since			7.0

   469 		@param			aDataLogger The output logging object.

   470 		@param			aObserver The observer of this UnitTest.

   471 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   472 		@pre 			None.

   473 		@post			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully constructed.

   474 	*/

   475 	inline CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest(CDataLogger& aDataLogger,

   476 											MUnitTestObserver& aObserver);

   477 

   478 	/**

   479 		@fn				void ConstructL()

   480 		Intended Usage	: Second phase of safe two phase construction, 

   481 		to complete the object initialisation.

   482 		Error Condition	: Leaves with an error code.

   483 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   484 		@since			7.0

   485 		@return			None 

   486 		@pre 			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully constructed.

   487 		@post			CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest is fully initialized.

   488 	*/

   489 	void ConstructL();

   490 

   491 	/**

   492 	The context of the Unit Test.

   493 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   494 	 */

   495 	CWspHeaderWriter_UnitTestContext* iUTContext;

   496 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   497 	/* C'tor, d'tor, and method transition validators */

   498 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   499 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iAuthorizationBasicNullUserValidator;

   500 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   501 	};	// CWspHeaderWriter_AuthorizationBasicNullUser_UnitTest

   502 

   503 // ______________________________________________________________________________

   504 //

   505 /**

   506 	@internal

   507 	@class CWspHeaderWriter_BasicNullPassword_UnitTest

   508 	@Depends CWspHeaderWriter & CUnitTest 

   509 

   510 	Comments : Unit Test for BasicNullPassword on CWspHeaderWriter, the class under test.

   511  */

   512 class CWspHeaderWriter_BasicNullPassword_UnitTest : public CUnitTest

   513 	{

   514 public:

   515 	/**

   516 		@fn				NewL(CDataLogger& aDataLogger,

   517 							MUnitTestObserver& aObserver)

   518 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   519 						cleanup stack.

   520 		Error Condition	: Leaves with the error code.

   521 		@exceptions		KErrNoMemory

   522 		@since			7.0

   523 		@param			aDataLogger The output logging object.

   524 		@param			aObserver The observer of this UnitTest.

   525 		@return			CWspHeaderWriter_BasicNullPassword_UnitTest* The constructed object.

   526 		@pre 			None.

   527 		@post			CWspHeaderWriter_BasicNullPassword_UnitTest is fully constructed, and initialized.

   528 	 */

   529 	static CWspHeaderWriter_BasicNullPassword_UnitTest* NewL(CDataLogger& aDataLogger,

   530 											MUnitTestObserver& aObserver);

   531 

   532 	/**

   533 		@fn				RunError(TInt aError)

   534 		Intended Usage	: Intercept the panic caused by a RunL leave,

   535 						to restore the CWspHeaderWriter_BasicNullPassword_UnitTest

   536 						object to a sensible state.

   537 						(called by the Active Scheduler immediately before the Panic).

   538 		Error Condition	: @see CUnitTest::RunError().

   539 		@since			7.0

   540 		@return			KErrNone if cleanup successful, otherwise

   541 						@see CUnitTest::RunError()

   542 		@pre 			CWspHeaderWriter_BasicNullPassword_UnitTest is fully constructed, and initialized.

   543 		@post			The object has been restored to a sensible state.

   544 	 */

   545 	inline TInt RunError(TInt aError);

   546 

   547 	/**

   548 		@fn				~CWspHeaderWriter_BasicNullPassword_UnitTest()

   549 		Intended Usage	: Standard Destructor.

   550 		Error Condition	: None.	

   551 		@since			7.0

   552 		@pre 			CWspHeaderWriter_BasicNullPassword_UnitTest is fully constructed.

   553 		@post			CWspHeaderWriter_BasicNullPassword_UnitTest is fully destroyed.

   554 	*/

   555 	~CWspHeaderWriter_BasicNullPassword_UnitTest();

   556 

   557 private:

   558 	/**

   559 		@fn				CWspHeaderWriter_BasicNullPassword_UnitTest(CDataLogger& aDataLogger,

   560 														MUnitTestObserver& aObserver)

   561 		Intended Usage	: Default constructor.

   562 		Error Condition	: None. 

   563 		@since			7.0

   564 		@param			aDataLogger The output logging object.

   565 		@param			aObserver The observer of this UnitTest.

   566 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   567 		@pre 			None.

   568 		@post			CWspHeaderWriter_BasicNullPassword_UnitTest is fully constructed.

   569 	*/

   570 	inline CWspHeaderWriter_BasicNullPassword_UnitTest(CDataLogger& aDataLogger,

   571 											MUnitTestObserver& aObserver);

   572 

   573 	/**

   574 		@fn				void ConstructL()

   575 		Intended Usage	: Second phase of safe two phase construction, 

   576 		to complete the object initialisation.

   577 		Error Condition	: Leaves with an error code.

   578 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   579 		@since			7.0

   580 		@return			None 

   581 		@pre 			CWspHeaderWriter_BasicNullPassword_UnitTest is fully constructed.

   582 		@post			CWspHeaderWriter_BasicNullPassword_UnitTest is fully initialized.

   583 	*/

   584 	void ConstructL();

   585 

   586 	/**

   587 	The context of the Unit Test.

   588 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   589 	 */

   590 	CWspHeaderWriter_UnitTestContext* iUTContext;

   591 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   592 	/* C'tor, d'tor, and method transition validators */

   593 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   594 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iBasicNullPasswordValidator;

   595 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   596 	};	// CWspHeaderWriter_BasicNullPassword_UnitTest

   597 

   598 // ______________________________________________________________________________

   599 //

   600 /**

   601 	@internal

   602 	@class CWspHeaderWriter_BasicNullUserNullPass_UnitTest

   603 	@Depends CWspHeaderWriter & CUnitTest 

   604 

   605 	Comments : Unit Test for BasicNullUserNullPass on CWspHeaderWriter, the class under test.

   606  */

   607 class CWspHeaderWriter_BasicNullUserNullPass_UnitTest : public CUnitTest

   608 	{

   609 public:

   610 	/**

   611 		@fn				NewL(CDataLogger& aDataLogger,

   612 							MUnitTestObserver& aObserver)

   613 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   614 						cleanup stack.

   615 		Error Condition	: Leaves with the error code.

   616 		@exceptions		KErrNoMemory

   617 		@since			7.0

   618 		@param			aDataLogger The output logging object.

   619 		@param			aObserver The observer of this UnitTest.

   620 		@return			CWspHeaderWriter_BasicNullUserNullPass_UnitTest* The constructed object.

   621 		@pre 			None.

   622 		@post			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully constructed, and initialized.

   623 	 */

   624 	static CWspHeaderWriter_BasicNullUserNullPass_UnitTest* NewL(CDataLogger& aDataLogger,

   625 											MUnitTestObserver& aObserver);

   626 

   627 	/**

   628 		@fn				RunError(TInt aError)

   629 		Intended Usage	: Intercept the panic caused by a RunL leave,

   630 						to restore the CWspHeaderWriter_BasicNullUserNullPass_UnitTest

   631 						object to a sensible state.

   632 						(called by the Active Scheduler immediately before the Panic).

   633 		Error Condition	: @see CUnitTest::RunError().

   634 		@since			7.0

   635 		@return			KErrNone if cleanup successful, otherwise

   636 						@see CUnitTest::RunError()

   637 		@pre 			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully constructed, and initialized.

   638 		@post			The object has been restored to a sensible state.

   639 	 */

   640 	inline TInt RunError(TInt aError);

   641 

   642 	/**

   643 		@fn				~CWspHeaderWriter_BasicNullUserNullPass_UnitTest()

   644 		Intended Usage	: Standard Destructor.

   645 		Error Condition	: None.	

   646 		@since			7.0

   647 		@pre 			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully constructed.

   648 		@post			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully destroyed.

   649 	*/

   650 	~CWspHeaderWriter_BasicNullUserNullPass_UnitTest();

   651 

   652 private:

   653 	/**

   654 		@fn				CWspHeaderWriter_BasicNullUserNullPass_UnitTest(CDataLogger& aDataLogger,

   655 														MUnitTestObserver& aObserver)

   656 		Intended Usage	: Default constructor.

   657 		Error Condition	: None. 

   658 		@since			7.0

   659 		@param			aDataLogger The output logging object.

   660 		@param			aObserver The observer of this UnitTest.

   661 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   662 		@pre 			None.

   663 		@post			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully constructed.

   664 	*/

   665 	inline CWspHeaderWriter_BasicNullUserNullPass_UnitTest(CDataLogger& aDataLogger,

   666 											MUnitTestObserver& aObserver);

   667 

   668 	/**

   669 		@fn				void ConstructL()

   670 		Intended Usage	: Second phase of safe two phase construction, 

   671 		to complete the object initialisation.

   672 		Error Condition	: Leaves with an error code.

   673 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   674 		@since			7.0

   675 		@return			None 

   676 		@pre 			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully constructed.

   677 		@post			CWspHeaderWriter_BasicNullUserNullPass_UnitTest is fully initialized.

   678 	*/

   679 	void ConstructL();

   680 

   681 	/**

   682 	The context of the Unit Test.

   683 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   684 	 */

   685 	CWspHeaderWriter_UnitTestContext* iUTContext;

   686 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   687 	/* C'tor, d'tor, and method transition validators */

   688 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   689 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iBasicNullUserNullPassValidator;

   690 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   691 	};	// CWspHeaderWriter_BasicNullUserNullPass_UnitTest

   692 

   693 // ______________________________________________________________________________

   694 //

   695 /**

   696 	@internal

   697 	@class CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest

   698 	@Depends CWspHeaderWriter & CUnitTest 

   699 

   700 	Comments : Unit Test for AuthorizationSchemeNoParam on CWspHeaderWriter, the class under test.

   701  */

   702 class CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest : public CUnitTest

   703 	{

   704 public:

   705 	/**

   706 		@fn				NewL(CDataLogger& aDataLogger,

   707 							MUnitTestObserver& aObserver)

   708 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   709 						cleanup stack.

   710 		Error Condition	: Leaves with the error code.

   711 		@exceptions		KErrNoMemory

   712 		@since			7.0

   713 		@param			aDataLogger The output logging object.

   714 		@param			aObserver The observer of this UnitTest.

   715 		@return			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest* The constructed object.

   716 		@pre 			None.

   717 		@post			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully constructed, and initialized.

   718 	 */

   719 	static CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest* NewL(CDataLogger& aDataLogger,

   720 											MUnitTestObserver& aObserver);

   721 

   722 	/**

   723 		@fn				RunError(TInt aError)

   724 		Intended Usage	: Intercept the panic caused by a RunL leave,

   725 						to restore the CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest

   726 						object to a sensible state.

   727 						(called by the Active Scheduler immediately before the Panic).

   728 		Error Condition	: @see CUnitTest::RunError().

   729 		@since			7.0

   730 		@return			KErrNone if cleanup successful, otherwise

   731 						@see CUnitTest::RunError()

   732 		@pre 			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully constructed, and initialized.

   733 		@post			The object has been restored to a sensible state.

   734 	 */

   735 	inline TInt RunError(TInt aError);

   736 

   737 	/**

   738 		@fn				~CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest()

   739 		Intended Usage	: Standard Destructor.

   740 		Error Condition	: None.	

   741 		@since			7.0

   742 		@pre 			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully constructed.

   743 		@post			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully destroyed.

   744 	*/

   745 	~CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest();

   746 

   747 private:

   748 	/**

   749 		@fn				CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest(CDataLogger& aDataLogger,

   750 														MUnitTestObserver& aObserver)

   751 		Intended Usage	: Default constructor.

   752 		Error Condition	: None. 

   753 		@since			7.0

   754 		@param			aDataLogger The output logging object.

   755 		@param			aObserver The observer of this UnitTest.

   756 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   757 		@pre 			None.

   758 		@post			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully constructed.

   759 	*/

   760 	inline CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest(CDataLogger& aDataLogger,

   761 											MUnitTestObserver& aObserver);

   762 

   763 	/**

   764 		@fn				void ConstructL()

   765 		Intended Usage	: Second phase of safe two phase construction, 

   766 		to complete the object initialisation.

   767 		Error Condition	: Leaves with an error code.

   768 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   769 		@since			7.0

   770 		@return			None 

   771 		@pre 			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully constructed.

   772 		@post			CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest is fully initialized.

   773 	*/

   774 	void ConstructL();

   775 

   776 	/**

   777 	The context of the Unit Test.

   778 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   779 	 */

   780 	CWspHeaderWriter_UnitTestContext* iUTContext;

   781 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   782 	/* C'tor, d'tor, and method transition validators */

   783 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   784 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iAuthorizationSchemeNoParamValidator;

   785 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   786 	};	// CWspHeaderWriter_AuthorizationSchemeNoParam_UnitTest

   787 

   788 // ______________________________________________________________________________

   789 //

   790 /**

   791 	@internal

   792 	@class CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest

   793 	@Depends CWspHeaderWriter & CUnitTest 

   794 

   795 	Comments : Unit Test for AuthorizationInvalidSchemeToken on CWspHeaderWriter, the class under test.

   796  */

   797 class CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest : public CUnitTest

   798 	{

   799 public:

   800 	/**

   801 		@fn				NewL(CDataLogger& aDataLogger,

   802 							MUnitTestObserver& aObserver)

   803 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   804 						cleanup stack.

   805 		Error Condition	: Leaves with the error code.

   806 		@exceptions		KErrNoMemory

   807 		@since			7.0

   808 		@param			aDataLogger The output logging object.

   809 		@param			aObserver The observer of this UnitTest.

   810 		@return			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest* The constructed object.

   811 		@pre 			None.

   812 		@post			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully constructed, and initialized.

   813 	 */

   814 	static CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest* NewL(CDataLogger& aDataLogger,

   815 											MUnitTestObserver& aObserver);

   816 

   817 	/**

   818 		@fn				RunError(TInt aError)

   819 		Intended Usage	: Intercept the panic caused by a RunL leave,

   820 						to restore the CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest

   821 						object to a sensible state.

   822 						(called by the Active Scheduler immediately before the Panic).

   823 		Error Condition	: @see CUnitTest::RunError().

   824 		@since			7.0

   825 		@return			KErrNone if cleanup successful, otherwise

   826 						@see CUnitTest::RunError()

   827 		@pre 			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully constructed, and initialized.

   828 		@post			The object has been restored to a sensible state.

   829 	 */

   830 	inline TInt RunError(TInt aError);

   831 

   832 	/**

   833 		@fn				~CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest()

   834 		Intended Usage	: Standard Destructor.

   835 		Error Condition	: None.	

   836 		@since			7.0

   837 		@pre 			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully constructed.

   838 		@post			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully destroyed.

   839 	*/

   840 	~CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest();

   841 

   842 private:

   843 	/**

   844 		@fn				CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest(CDataLogger& aDataLogger,

   845 														MUnitTestObserver& aObserver)

   846 		Intended Usage	: Default constructor.

   847 		Error Condition	: None. 

   848 		@since			7.0

   849 		@param			aDataLogger The output logging object.

   850 		@param			aObserver The observer of this UnitTest.

   851 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   852 		@pre 			None.

   853 		@post			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully constructed.

   854 	*/

   855 	inline CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest(CDataLogger& aDataLogger,

   856 											MUnitTestObserver& aObserver);

   857 

   858 	/**

   859 		@fn				void ConstructL()

   860 		Intended Usage	: Second phase of safe two phase construction, 

   861 		to complete the object initialisation.

   862 		Error Condition	: Leaves with an error code.

   863 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   864 		@since			7.0

   865 		@return			None 

   866 		@pre 			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully constructed.

   867 		@post			CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest is fully initialized.

   868 	*/

   869 	void ConstructL();

   870 

   871 	/**

   872 	The context of the Unit Test.

   873 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   874 	 */

   875 	CWspHeaderWriter_UnitTestContext* iUTContext;

   876 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   877 	/* C'tor, d'tor, and method transition validators */

   878 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   879 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iAuthorizationInvalidSchemeTokenValidator;

   880 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   881 	};	// CWspHeaderWriter_AuthorizationInvalidSchemeToken_UnitTest

   882 

   883 // ______________________________________________________________________________

   884 //

   885 /**

   886 	@internal

   887 	@class CWspHeaderWriter_AuthorizationScheme2Params_UnitTest

   888 	@Depends CWspHeaderWriter & CUnitTest 

   889 

   890 	Comments : Unit Test for AuthorizationScheme2Params on CWspHeaderWriter, the class under test.

   891  */

   892 class CWspHeaderWriter_AuthorizationScheme2Params_UnitTest : public CUnitTest

   893 	{

   894 public:

   895 	/**

   896 		@fn				NewL(CDataLogger& aDataLogger,

   897 							MUnitTestObserver& aObserver)

   898 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   899 						cleanup stack.

   900 		Error Condition	: Leaves with the error code.

   901 		@exceptions		KErrNoMemory

   902 		@since			7.0

   903 		@param			aDataLogger The output logging object.

   904 		@param			aObserver The observer of this UnitTest.

   905 		@return			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest* The constructed object.

   906 		@pre 			None.

   907 		@post			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully constructed, and initialized.

   908 	 */

   909 	static CWspHeaderWriter_AuthorizationScheme2Params_UnitTest* NewL(CDataLogger& aDataLogger,

   910 											MUnitTestObserver& aObserver);

   911 

   912 	/**

   913 		@fn				RunError(TInt aError)

   914 		Intended Usage	: Intercept the panic caused by a RunL leave,

   915 						to restore the CWspHeaderWriter_AuthorizationScheme2Params_UnitTest

   916 						object to a sensible state.

   917 						(called by the Active Scheduler immediately before the Panic).

   918 		Error Condition	: @see CUnitTest::RunError().

   919 		@since			7.0

   920 		@return			KErrNone if cleanup successful, otherwise

   921 						@see CUnitTest::RunError()

   922 		@pre 			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully constructed, and initialized.

   923 		@post			The object has been restored to a sensible state.

   924 	 */

   925 	inline TInt RunError(TInt aError);

   926 

   927 	/**

   928 		@fn				~CWspHeaderWriter_AuthorizationScheme2Params_UnitTest()

   929 		Intended Usage	: Standard Destructor.

   930 		Error Condition	: None.	

   931 		@since			7.0

   932 		@pre 			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully constructed.

   933 		@post			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully destroyed.

   934 	*/

   935 	~CWspHeaderWriter_AuthorizationScheme2Params_UnitTest();

   936 

   937 private:

   938 	/**

   939 		@fn				CWspHeaderWriter_AuthorizationScheme2Params_UnitTest(CDataLogger& aDataLogger,

   940 														MUnitTestObserver& aObserver)

   941 		Intended Usage	: Default constructor.

   942 		Error Condition	: None. 

   943 		@since			7.0

   944 		@param			aDataLogger The output logging object.

   945 		@param			aObserver The observer of this UnitTest.

   946 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

   947 		@pre 			None.

   948 		@post			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully constructed.

   949 	*/

   950 	inline CWspHeaderWriter_AuthorizationScheme2Params_UnitTest(CDataLogger& aDataLogger,

   951 											MUnitTestObserver& aObserver);

   952 

   953 	/**

   954 		@fn				void ConstructL()

   955 		Intended Usage	: Second phase of safe two phase construction, 

   956 		to complete the object initialisation.

   957 		Error Condition	: Leaves with an error code.

   958 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

   959 		@since			7.0

   960 		@return			None 

   961 		@pre 			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully constructed.

   962 		@post			CWspHeaderWriter_AuthorizationScheme2Params_UnitTest is fully initialized.

   963 	*/

   964 	void ConstructL();

   965 

   966 	/**

   967 	The context of the Unit Test.

   968 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

   969 	 */

   970 	CWspHeaderWriter_UnitTestContext* iUTContext;

   971 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

   972 	/* C'tor, d'tor, and method transition validators */

   973 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

   974 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iAuthorizationScheme2ParamsValidator;

   975 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

   976 	};	// CWspHeaderWriter_AuthorizationScheme2Params_UnitTest

   977 

   978 // ______________________________________________________________________________

   979 //

   980 /**

   981 	@internal

   982 	@class CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest

   983 	@Depends CWspHeaderWriter & CUnitTest 

   984 

   985 	Comments : Unit Test for AuthorizationScheme2ParamV1_2 on CWspHeaderWriter, the class under test.

   986  */

   987 class CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest : public CUnitTest

   988 	{

   989 public:

   990 	/**

   991 		@fn				NewL(CDataLogger& aDataLogger,

   992 							MUnitTestObserver& aObserver)

   993 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   994 						cleanup stack.

   995 		Error Condition	: Leaves with the error code.

   996 		@exceptions		KErrNoMemory

   997 		@since			7.0

   998 		@param			aDataLogger The output logging object.

   999 		@param			aObserver The observer of this UnitTest.

  1000 		@return			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest* The constructed object.

  1001 		@pre 			None.

  1002 		@post			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully constructed, and initialized.

  1003 	 */

  1004 	static CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest* NewL(CDataLogger& aDataLogger,

  1005 											MUnitTestObserver& aObserver);

  1006 

  1007 	/**

  1008 		@fn				RunError(TInt aError)

  1009 		Intended Usage	: Intercept the panic caused by a RunL leave,

  1010 						to restore the CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest

  1011 						object to a sensible state.

  1012 						(called by the Active Scheduler immediately before the Panic).

  1013 		Error Condition	: @see CUnitTest::RunError().

  1014 		@since			7.0

  1015 		@return			KErrNone if cleanup successful, otherwise

  1016 						@see CUnitTest::RunError()

  1017 		@pre 			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully constructed, and initialized.

  1018 		@post			The object has been restored to a sensible state.

  1019 	 */

  1020 	inline TInt RunError(TInt aError);

  1021 

  1022 	/**

  1023 		@fn				~CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest()

  1024 		Intended Usage	: Standard Destructor.

  1025 		Error Condition	: None.	

  1026 		@since			7.0

  1027 		@pre 			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully constructed.

  1028 		@post			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully destroyed.

  1029 	*/

  1030 	~CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest();

  1031 

  1032 private:

  1033 	/**

  1034 		@fn				CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest(CDataLogger& aDataLogger,

  1035 														MUnitTestObserver& aObserver)

  1036 		Intended Usage	: Default constructor.

  1037 		Error Condition	: None. 

  1038 		@since			7.0

  1039 		@param			aDataLogger The output logging object.

  1040 		@param			aObserver The observer of this UnitTest.

  1041 		@param			aStateAccessor WhiteBox state access to the CWspHeaderWriter class.

  1042 		@pre 			None.

  1043 		@post			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully constructed.

  1044 	*/

  1045 	inline CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest(CDataLogger& aDataLogger,

  1046 											MUnitTestObserver& aObserver);

  1047 

  1048 	/**

  1049 		@fn				void ConstructL()

  1050 		Intended Usage	: Second phase of safe two phase construction, 

  1051 		to complete the object initialisation.

  1052 		Error Condition	: Leaves with an error code.

  1053 		@exception		KErrNoMemory, and @see CUnitTest::BaseNewL().

  1054 		@since			7.0

  1055 		@return			None 

  1056 		@pre 			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully constructed.

  1057 		@post			CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest is fully initialized.

  1058 	*/

  1059 	void ConstructL();

  1060 

  1061 	/**

  1062 	The context of the Unit Test.

  1063 	i.e The CWspHeaderWriter class tested by this UnitTest's transitions.

  1064 	 */

  1065 	CWspHeaderWriter_UnitTestContext* iUTContext;

  1066 	TWspHeaderWriter_StateAccessor*	iStateAccessor;

  1067 	/* C'tor, d'tor, and method transition validators */

  1068 	TWspHeaderWriter_Ctor_TransitionValidator*	iCtorValidator;

  1069 	TWspHeaderWriter_EncodeHeaderL_TransitionValidator*	iAuthorizationScheme2ParamV1_2Validator;

  1070 	TWspHeaderWriter_Dtor_TransitionValidator*	iDtorValidator;

  1071 	};	// CWspHeaderWriter_AuthorizationScheme2ParamV1_2_UnitTest

  1072 

  1073 // ______________________________________________________________________________

  1074 //

  1075 /**

  1076 	@internal

  1077 	@class CWspHeaderWriter_ContentLocation_UnitTest

  1078 	@Depends CWspHeaderWriter & CUnitTest 

  1079 

  1080 	Comments : Unit Test for ContentLocation on CWspHeaderWriter, the class under test.

  1081  */

  1082 class CWspHeaderWriter_ContentLocation_UnitTest : public CUnitTest

  1083 	{

  1084 public:

  1085 	/**

  1086 		@fn				NewL(CDataLogger& aDataLogger,

  1087 							MUnitTestObserver& aObserver)

  1088 		Intended Usage	: Standard two-phase construction which leaves nothing on the

  1089 						cleanup stack.

  1090 		Error Condition	: Leaves with the error code.

  1091 		@exceptions		KErrNoMemory

  1092 		@since			7.0

  1093 		@param			aDataLogger The output logging object.

  1094 		@param			aObserver The observer of this UnitTest.

  1095 		@return			CWspHeaderWriter_ContentLocation_UnitTest* The constructed object.

  1096 		@pre 			None.

  1097 		@post			CWspHeaderWriter_ContentLocation_UnitTest is fully constructed, and initialized.

  1098 	 */

  1099 	static CWspHeaderWriter_ContentLocation_UnitTest* NewL(CDataLogger& aDataLogger,

  1100 											MUnitTestObserver& aObserver);

  1101 

  1102 	/**

  1103 		@fn				RunError(TInt aError)

  1104 		Intended Usage	: Intercept the panic caused by a RunL leave,

  1105 						to restore the CWspHeaderWriter_ContentLocation_UnitTest

  1106 						object to a sensible state.

  1107 						(called by the Active Scheduler immediately before the Panic).

  1108 		Error Condition	: @see CUnitTest::RunError().

  1109 		@since			7.0

  1110 		@return			KErrNone if cleanup successful, otherwise

  1111 						@see CUnitTest::RunError()

  1112 		@pre 			CWspHeaderWriter_ContentLocation_UnitTest is fully constructed, and initialized.

  1113 		@post			The object has been restored to a sensible state.

  1114 	 */

  1115 	inline TInt RunError(TInt aError);

  1116 

  1117 	/**

  1118 		@fn				~CWspHeaderWriter_ContentLocation_UnitTest()

  1119 		Intended Usage	: Standard Destructor.

  1120 		Error Condition	: None.	

  1121 		@since			7.0

  1122 		@pre 			CWspHeaderWriter_ContentLocation_UnitTest is fully constructed.

  1123 		@post			CWspHeaderWriter_ContentLocation_UnitTest is fully destroyed.

  1124 	*/

  1125 	~CWspHeaderWriter_ContentLocation_UnitTest();

  1126 

  1127 private:

  1128 	/**

  1129 		@fn				CWspHeaderWriter_ContentLocation_UnitTest(CDataLogger& aDataLogger,

  1130 														MUnitTestObserver& aObserver)

  1131 		Intended Usage	: Default constructor.

  1132 		Error Condition	: None. 

  1133 		@since			7.0

  1134 		@param			aDataLogger The output logging object.

  1135 		@param			aObserver The observer of this UnitTest.