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 implementations for the CWspHeaderReader class.

    15 // 

    16 //

    17 

    18 /**

    19  @file WspHeaderReaderUnitTest.cpp

    20 */

    21 

    22 #include "WspHeaderReaderUnitTest.h"

    23 

    24 // System includes

    25 #include <wspstringconstants.h>

    26 

    27 // ______________________________________________________________________________

    28 //

    29 _LIT(KWspHeaderReaderCreateAndDestroyUnitTest,"CWspHeaderReader_CreateAndDestroy_UnitTest");

    30 

    31 CWspHeaderReader_CreateAndDestroy_UnitTest* CWspHeaderReader_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,

    32 											MUnitTestObserver& aObserver)

    33 	{

    34 	CWspHeaderReader_CreateAndDestroy_UnitTest* self = 

    35 					new(ELeave) CWspHeaderReader_CreateAndDestroy_UnitTest(aDataLogger,

    36 																aObserver);

    37 	CleanupStack::PushL(self);

    38 	self->ConstructL();

    39 	CleanupStack::Pop(self);

    40 	return self; 

    41 	}

    42 

    43 inline TInt CWspHeaderReader_CreateAndDestroy_UnitTest::RunError(TInt aError)

    44 	{

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

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

    47 	delete iUTContext;

    48 	iUTContext = NULL;

    49 	delete iStateAccessor;

    50 	iStateAccessor = NULL;

    51 	/* delete any validators used */

    52 	delete iCtorValidator;

    53 	iCtorValidator = NULL;

    54 	delete iDtorValidator;

    55 	iDtorValidator = NULL;

    56 	return error;

    57 	}

    58 

    59 inline CWspHeaderReader_CreateAndDestroy_UnitTest::~CWspHeaderReader_CreateAndDestroy_UnitTest()

    60 	{

    61 	// Simply delete our test class instance

    62 	delete iUTContext;

    63 	delete iStateAccessor;

    64 	/* delete any validators used */

    65 	delete iCtorValidator;

    66 	delete iDtorValidator;

    67 	}

    68 

    69 inline CWspHeaderReader_CreateAndDestroy_UnitTest::CWspHeaderReader_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    70 																	MUnitTestObserver& aObserver)

    71 : CUnitTest(KWspHeaderReaderCreateAndDestroyUnitTest, aDataLogger, aObserver)

    72 	{

    73 	//Do nothing

    74 	}

    75 

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

    77 inline void CWspHeaderReader_CreateAndDestroy_UnitTest::ConstructL()

    78 	{

    79 	// Perform the base class initialization

    80 	UnitTestConstructL();

    81 

    82 	// Create the Unit test state accessor

    83 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

    84 	// Construct the Unit test context.

    85 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

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

    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 CWspHeaderReader class.

    90 		using constructor and destuctor validators */

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

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

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

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

    95 	}

    96 

    97 // ______________________________________________________________________________

    98 //

    99 _LIT(KWspHeaderReaderContentTypeShortTokenUnitTest,"CWspHeaderReader_ContentTypeShortToken_UnitTest");

   100 

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

   102 											MUnitTestObserver& aObserver)

   103 	{

   104 	CWspHeaderReader_ContentTypeShortToken_UnitTest* self = 

   105 					new(ELeave) CWspHeaderReader_ContentTypeShortToken_UnitTest(aDataLogger,

   106 																aObserver);

   107 	CleanupStack::PushL(self);

   108 	self->ConstructL();

   109 	CleanupStack::Pop(self);

   110 	return self; 

   111 	}

   112 

   113 inline TInt CWspHeaderReader_ContentTypeShortToken_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 iContentTypeShortTokenValidator;

   125 	iContentTypeShortTokenValidator = NULL;

   126 	delete iDtorValidator;

   127 	iDtorValidator = NULL;

   128 	return error;

   129 	}

   130 

   131 inline CWspHeaderReader_ContentTypeShortToken_UnitTest::~CWspHeaderReader_ContentTypeShortToken_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 iContentTypeShortTokenValidator;

   139 	delete iDtorValidator;

   140 	}

   141 

   142 inline CWspHeaderReader_ContentTypeShortToken_UnitTest::CWspHeaderReader_ContentTypeShortToken_UnitTest(CDataLogger& aDataLogger,

   143 																	MUnitTestObserver& aObserver)

   144 : CUnitTest(KWspHeaderReaderContentTypeShortTokenUnitTest, aDataLogger, aObserver)

   145 	{

   146 	//Do nothing

   147 	}

   148 

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

   150 inline void CWspHeaderReader_ContentTypeShortToken_UnitTest::ConstructL()

   151 	{

   152 	// Perform the base class initialization

   153 	UnitTestConstructL();

   154 

   155 	// Create the Unit test state accessor

   156 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   157 	// Construct the Unit test context.

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

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

   160 	iUTContext->iTestHeader->BeginRawDataL();

   161 	TUint8 octet81 = 0x81; // Should be token value for text/*

   162 	iUTContext->iTestHeader->WriteRawDataL(octet81);

   163 	iUTContext->iTestHeader->CommitRawData();

   164 	_LIT8(KTxtExpected, "text/*");

   165 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   168 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   169 		using constructor and destuctor validators */

   170 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   171 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   172 	iContentTypeShortTokenValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   173 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeShortTokenValidator));

   174 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   175 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   176 	}

   177 

   178 // ______________________________________________________________________________

   179 //

   180 _LIT(KWspHeaderReaderContentTypeExtensionMediaUnitTest,"CWspHeaderReader_ContentTypeExtensionMedia_UnitTest");

   181 

   182 CWspHeaderReader_ContentTypeExtensionMedia_UnitTest* CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::NewL(CDataLogger& aDataLogger,

   183 											MUnitTestObserver& aObserver)

   184 	{

   185 	CWspHeaderReader_ContentTypeExtensionMedia_UnitTest* self = 

   186 					new(ELeave) CWspHeaderReader_ContentTypeExtensionMedia_UnitTest(aDataLogger,

   187 																aObserver);

   188 	CleanupStack::PushL(self);

   189 	self->ConstructL();

   190 	CleanupStack::Pop(self);

   191 	return self; 

   192 	}

   193 

   194 inline TInt CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::RunError(TInt aError)

   195 	{

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

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

   198 	delete iUTContext;

   199 	iUTContext = NULL;

   200 	delete iStateAccessor;

   201 	iStateAccessor = NULL;

   202 	/* delete any validators used */

   203 	delete iCtorValidator;

   204 	iCtorValidator = NULL;

   205 	delete iContentTypeExtensionMediaValidator;

   206 	iContentTypeExtensionMediaValidator = NULL;

   207 	delete iDtorValidator;

   208 	iDtorValidator = NULL;

   209 	return error;

   210 	}

   211 

   212 inline CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::~CWspHeaderReader_ContentTypeExtensionMedia_UnitTest()

   213 	{

   214 	// Simply delete our test class instance

   215 	delete iUTContext;

   216 	delete iStateAccessor;

   217 	/* delete any validators used */

   218 	delete iCtorValidator;

   219 	delete iContentTypeExtensionMediaValidator;

   220 	delete iDtorValidator;

   221 	}

   222 

   223 inline CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::CWspHeaderReader_ContentTypeExtensionMedia_UnitTest(CDataLogger& aDataLogger,

   224 																	MUnitTestObserver& aObserver)

   225 : CUnitTest(KWspHeaderReaderContentTypeExtensionMediaUnitTest, aDataLogger, aObserver)

   226 	{

   227 	//Do nothing

   228 	}

   229 

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

   231 inline void CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::ConstructL()

   232 	{

   233 	// Perform the base class initialization

   234 	UnitTestConstructL();

   235 

   236 	// Create the Unit test state accessor

   237 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   238 	// Construct the Unit test context.

   239 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   240 	iUTContext->ConstructL(WSP::EContentType);

   241 	iUTContext->iTestHeader->BeginRawDataL();

   242 	_LIT8(KTxtData, "extension/media\0");

   243 	iUTContext->iTestHeader->WriteRawDataL(KTxtData());

   244 	iUTContext->iTestHeader->CommitRawData();

   245 	_LIT8(KTxtExpected, "extension/media");

   246 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   249 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   250 		using constructor and destuctor validators */

   251 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   252 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   253 	iContentTypeExtensionMediaValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   254 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeExtensionMediaValidator));

   255 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   256 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   257 	}

   258 

   259 // ______________________________________________________________________________

   260 //

   261 _LIT(KWspHeaderReaderContentTypeNullUnitTest,"CWspHeaderReader_ContentTypeNull_UnitTest");

   262 

   263 CWspHeaderReader_ContentTypeNull_UnitTest* CWspHeaderReader_ContentTypeNull_UnitTest::NewL(CDataLogger& aDataLogger,

   264 											MUnitTestObserver& aObserver)

   265 	{

   266 	CWspHeaderReader_ContentTypeNull_UnitTest* self = 

   267 					new(ELeave) CWspHeaderReader_ContentTypeNull_UnitTest(aDataLogger,

   268 																aObserver);

   269 	CleanupStack::PushL(self);

   270 	self->ConstructL();

   271 	CleanupStack::Pop(self);

   272 	return self; 

   273 	}

   274 

   275 inline TInt CWspHeaderReader_ContentTypeNull_UnitTest::RunError(TInt aError)

   276 	{

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

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

   279 	delete iUTContext;

   280 	iUTContext = NULL;

   281 	delete iStateAccessor;

   282 	iStateAccessor = NULL;

   283 	/* delete any validators used */

   284 	delete iCtorValidator;

   285 	iCtorValidator = NULL;

   286 	delete iContentTypeNullValidator;

   287 	iContentTypeNullValidator = NULL;

   288 	delete iDtorValidator;

   289 	iDtorValidator = NULL;

   290 	return error;

   291 	}

   292 

   293 inline CWspHeaderReader_ContentTypeNull_UnitTest::~CWspHeaderReader_ContentTypeNull_UnitTest()

   294 	{

   295 	// Simply delete our test class instance

   296 	delete iUTContext;

   297 	delete iStateAccessor;

   298 	/* delete any validators used */

   299 	delete iCtorValidator;

   300 	delete iContentTypeNullValidator;

   301 	delete iDtorValidator;

   302 	}

   303 

   304 inline CWspHeaderReader_ContentTypeNull_UnitTest::CWspHeaderReader_ContentTypeNull_UnitTest(CDataLogger& aDataLogger,

   305 																	MUnitTestObserver& aObserver)

   306 : CUnitTest(KWspHeaderReaderContentTypeNullUnitTest, aDataLogger, aObserver)

   307 	{

   308 	//Do nothing

   309 	}

   310 

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

   312 inline void CWspHeaderReader_ContentTypeNull_UnitTest::ConstructL()

   313 	{

   314 	// Perform the base class initialization

   315 	UnitTestConstructL();

   316 

   317 	// Create the Unit test state accessor

   318 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   319 	// Construct the Unit test context.

   320 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   321 	iUTContext->ConstructL(WSP::EContentType);

   322 	iUTContext->iTestHeader->BeginRawDataL();

   323 	TUint8 octet00 = 0x00;

   324 	iUTContext->iTestHeader->WriteRawDataL(octet00);

   325 	iUTContext->iTestHeader->CommitRawData();

   326 	iUTContext->SetExpectedL(KNullDesC8());

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

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

   329 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   330 		using constructor and destuctor validators */

   331 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   332 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   333 	iContentTypeNullValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   334 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeNullValidator));

   335 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   336 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   337 	}

   338 

   339 // ______________________________________________________________________________

   340 //

   341 _LIT(KWspHeaderReaderContentTypeWellKnownMediaIntUnitTest,"CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest");

   342 

   343 CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest* CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::NewL(CDataLogger& aDataLogger,

   344 											MUnitTestObserver& aObserver)

   345 	{

   346 	CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest* self = 

   347 					new(ELeave) CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest(aDataLogger,

   348 																aObserver);

   349 	CleanupStack::PushL(self);

   350 	self->ConstructL();

   351 	CleanupStack::Pop(self);

   352 	return self; 

   353 	}

   354 

   355 inline TInt CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::RunError(TInt aError)

   356 	{

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

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

   359 	delete iUTContext;

   360 	iUTContext = NULL;

   361 	delete iStateAccessor;

   362 	iStateAccessor = NULL;

   363 	/* delete any validators used */

   364 	delete iCtorValidator;

   365 	iCtorValidator = NULL;

   366 	delete iContentTypeWellKnownMediaIntValidator;

   367 	iContentTypeWellKnownMediaIntValidator = NULL;

   368 	delete iDtorValidator;

   369 	iDtorValidator = NULL;

   370 	return error;

   371 	}

   372 

   373 inline CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::~CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest()

   374 	{

   375 	// Simply delete our test class instance

   376 	delete iUTContext;

   377 	delete iStateAccessor;

   378 	/* delete any validators used */

   379 	delete iCtorValidator;

   380 	delete iContentTypeWellKnownMediaIntValidator;

   381 	delete iDtorValidator;

   382 	}

   383 

   384 inline CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest(CDataLogger& aDataLogger,

   385 																	MUnitTestObserver& aObserver)

   386 : CUnitTest(KWspHeaderReaderContentTypeWellKnownMediaIntUnitTest, aDataLogger, aObserver)

   387 	{

   388 	//Do nothing

   389 	}

   390 

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

   392 inline void CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::ConstructL()

   393 	{

   394 	// Perform the base class initialization

   395 	UnitTestConstructL();

   396 

   397 	// Create the Unit test state accessor

   398 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   399 	// Construct the Unit test context.

   400 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   401 	iUTContext->ConstructL(WSP::EContentType);

   402 	iUTContext->iTestHeader->BeginRawDataL();

   403 	TUint8 octet02 = 0x02;

   404 	TUint8 octet03 = 0x03;

   405 	TUint8 octet0B = 0x0B;

   406 	iUTContext->iTestHeader->WriteRawDataL(octet03);

   407 	iUTContext->iTestHeader->WriteRawDataL(octet02);

   408 	iUTContext->iTestHeader->WriteRawDataL(octet02);

   409 	iUTContext->iTestHeader->WriteRawDataL(octet0B);

   410 	

   411 	iUTContext->iTestHeader->CommitRawData();

   412 	_LIT8(KTxtExpected, "application/vnd.nokia.syncset+wbxml");

   413 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   416 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   417 		using constructor and destuctor validators */

   418 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   419 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   420 	iContentTypeWellKnownMediaIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   421 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeWellKnownMediaIntValidator));

   422 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   423 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   424 	}

   425 

   426 // ______________________________________________________________________________

   427 //

   428 _LIT(KWspHeaderReaderContentTypeMediaTypeExtensionUnitTest,"CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest");

   429 

   430 CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest* CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::NewL(CDataLogger& aDataLogger,

   431 											MUnitTestObserver& aObserver)

   432 	{

   433 	CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest* self = 

   434 					new(ELeave) CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest(aDataLogger,

   435 																aObserver);

   436 	CleanupStack::PushL(self);

   437 	self->ConstructL();

   438 	CleanupStack::Pop(self);

   439 	return self; 

   440 	}

   441 

   442 inline TInt CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::RunError(TInt aError)

   443 	{

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

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

   446 	delete iUTContext;

   447 	iUTContext = NULL;

   448 	delete iStateAccessor;

   449 	iStateAccessor = NULL;

   450 	/* delete any validators used */

   451 	delete iCtorValidator;

   452 	iCtorValidator = NULL;

   453 	delete iContentTypeMediaTypeExtensionValidator;

   454 	iContentTypeMediaTypeExtensionValidator = NULL;

   455 	delete iDtorValidator;

   456 	iDtorValidator = NULL;

   457 	return error;

   458 	}

   459 

   460 inline CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::~CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest()

   461 	{

   462 	// Simply delete our test class instance

   463 	delete iUTContext;

   464 	delete iStateAccessor;

   465 	/* delete any validators used */

   466 	delete iCtorValidator;

   467 	delete iContentTypeMediaTypeExtensionValidator;

   468 	delete iDtorValidator;

   469 	}

   470 

   471 inline CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest(CDataLogger& aDataLogger,

   472 																	MUnitTestObserver& aObserver)

   473 : CUnitTest(KWspHeaderReaderContentTypeMediaTypeExtensionUnitTest, aDataLogger, aObserver)

   474 	{

   475 	//Do nothing

   476 	}

   477 

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

   479 inline void CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::ConstructL()

   480 	{

   481 	// Perform the base class initialization

   482 	UnitTestConstructL();

   483 

   484 	// Create the Unit test state accessor

   485 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   486 	// Construct the Unit test context.

   487 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   488 	iUTContext->ConstructL(WSP::EContentType);

   489 	iUTContext->iTestHeader->BeginRawDataL();

   490 	

   491 	TUint8 octet1F = 0x1F; // <Octet 31> for length quote

   492 	TUint8 octet82 = 0x82;

   493 	TUint8 octet2D = 0x2D;

   494 	TUint8 octet00 = 0x00; // NULL terminator

   495 	iUTContext->iTestHeader->WriteRawDataL(octet1F);

   496 	iUTContext->iTestHeader->WriteRawDataL(octet82);

   497 	iUTContext->iTestHeader->WriteRawDataL(octet2D);

   498 	_LIT8(KTxt10ByteData, "tenbyteapp");

   499 	for( TInt i=0; i<30; ++i )

   500 		{

   501 		iUTContext->iTestHeader->WriteRawDataL(KTxt10ByteData());

   502 		}

   503 	iUTContext->iTestHeader->WriteRawDataL(octet00);

   504 	iUTContext->iTestHeader->CommitRawData();

   505 

   506 	HBufC8* buf = HBufC8::NewL(300);

   507 	CleanupStack::PushL(buf);

   508 	TPtr8 appendBuf(buf->Des());

   509 	for( TInt i=0; i<30; ++i )

   510 		{

   511 		appendBuf.Append(KTxt10ByteData());

   512 		}

   513 	iUTContext->SetExpectedL(*buf);

   514 	CleanupStack::PopAndDestroy(buf);

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

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

   517 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   518 		using constructor and destuctor validators */

   519 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   520 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   521 	iContentTypeMediaTypeExtensionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   522 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeMediaTypeExtensionValidator));

   523 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   524 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   525 	}

   526 

   527 // ______________________________________________________________________________

   528 //

   529 _LIT(KWspHeaderReaderContentTypeWith1ParamUnitTest,"CWspHeaderReader_ContentTypeWith1Param_UnitTest");

   530 

   531 CWspHeaderReader_ContentTypeWith1Param_UnitTest* CWspHeaderReader_ContentTypeWith1Param_UnitTest::NewL(CDataLogger& aDataLogger,

   532 											MUnitTestObserver& aObserver)

   533 	{

   534 	CWspHeaderReader_ContentTypeWith1Param_UnitTest* self = 

   535 					new(ELeave) CWspHeaderReader_ContentTypeWith1Param_UnitTest(aDataLogger,

   536 																aObserver);

   537 	CleanupStack::PushL(self);

   538 	self->ConstructL();

   539 	CleanupStack::Pop(self);

   540 	return self; 

   541 	}

   542 

   543 inline TInt CWspHeaderReader_ContentTypeWith1Param_UnitTest::RunError(TInt aError)

   544 	{

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

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

   547 	delete iUTContext;

   548 	iUTContext = NULL;

   549 	delete iStateAccessor;

   550 	iStateAccessor = NULL;

   551 	/* delete any validators used */

   552 	delete iCtorValidator;

   553 	iCtorValidator = NULL;

   554 	delete iContentTypeWith1ParamValidator;

   555 	iContentTypeWith1ParamValidator = NULL;

   556 	delete iDtorValidator;

   557 	iDtorValidator = NULL;

   558 	return error;

   559 	}

   560 

   561 inline CWspHeaderReader_ContentTypeWith1Param_UnitTest::~CWspHeaderReader_ContentTypeWith1Param_UnitTest()

   562 	{

   563 	// Simply delete our test class instance

   564 	delete iUTContext;

   565 	delete iStateAccessor;

   566 	/* delete any validators used */

   567 	delete iCtorValidator;

   568 	delete iContentTypeWith1ParamValidator;

   569 	delete iDtorValidator;

   570 	}

   571 

   572 inline CWspHeaderReader_ContentTypeWith1Param_UnitTest::CWspHeaderReader_ContentTypeWith1Param_UnitTest(CDataLogger& aDataLogger,

   573 																	MUnitTestObserver& aObserver)

   574 : CUnitTest(KWspHeaderReaderContentTypeWith1ParamUnitTest, aDataLogger, aObserver)

   575 	{

   576 	//Do nothing

   577 	}

   578 

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

   580 inline void CWspHeaderReader_ContentTypeWith1Param_UnitTest::ConstructL()

   581 	{

   582 	// Perform the base class initialization

   583 	UnitTestConstructL();

   584 

   585 	// Create the Unit test state accessor

   586 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   587 	// Construct the Unit test context.

   588 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   589 	iUTContext->ConstructL(WSP::EContentType);

   590 	iUTContext->iTestHeader->BeginRawDataL();

   591 	TUint8 octet11 = 0x11; // short int length of 17 bytes

   592 	TUint8 octetA3 = 0xA3; // token for content type

   593 	TUint8 octet97 = 0x97; // token for well-known param

   594 	_LIT8(KTxtParamVal, "testparamvalue\0"); // param value

   595 

   596 	iUTContext->iTestHeader->WriteRawDataL(octet11);

   597 	iUTContext->iTestHeader->WriteRawDataL(octetA3);

   598 	iUTContext->iTestHeader->WriteRawDataL(octet97);

   599 	iUTContext->iTestHeader->WriteRawDataL(KTxtParamVal());

   600 	iUTContext->iTestHeader->CommitRawData();

   601 

   602 	_LIT8(KTxtExpected, "application/vnd.wap.multipart.mixed;Name=testparamvalue");

   603 	iUTContext->SetExpectedL(KTxtExpected());

   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 CWspHeaderReader class.

   607 		using constructor and destuctor validators */

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

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

   610 	iContentTypeWith1ParamValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   611 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeWith1ParamValidator));

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

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

   614 	}

   615 

   616 // ______________________________________________________________________________

   617 //

   618 _LIT(KWspHeaderReaderContentTypeWith2ParamsUnitTest,"CWspHeaderReader_ContentTypeWith2Params_UnitTest");

   619 

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

   621 											MUnitTestObserver& aObserver)

   622 	{

   623 	CWspHeaderReader_ContentTypeWith2Params_UnitTest* self = 

   624 					new(ELeave) CWspHeaderReader_ContentTypeWith2Params_UnitTest(aDataLogger,

   625 																aObserver);

   626 	CleanupStack::PushL(self);

   627 	self->ConstructL();

   628 	CleanupStack::Pop(self);

   629 	return self; 

   630 	}

   631 

   632 inline TInt CWspHeaderReader_ContentTypeWith2Params_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 iContentTypeWith2ParamsValidator;

   644 	iContentTypeWith2ParamsValidator = NULL;

   645 	delete iDtorValidator;

   646 	iDtorValidator = NULL;

   647 	return error;

   648 	}

   649 

   650 inline CWspHeaderReader_ContentTypeWith2Params_UnitTest::~CWspHeaderReader_ContentTypeWith2Params_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 iContentTypeWith2ParamsValidator;

   658 	delete iDtorValidator;

   659 	}

   660 

   661 inline CWspHeaderReader_ContentTypeWith2Params_UnitTest::CWspHeaderReader_ContentTypeWith2Params_UnitTest(CDataLogger& aDataLogger,

   662 																	MUnitTestObserver& aObserver)

   663 : CUnitTest(KWspHeaderReaderContentTypeWith2ParamsUnitTest, aDataLogger, aObserver)

   664 	{

   665 	//Do nothing

   666 	}

   667 

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

   669 inline void CWspHeaderReader_ContentTypeWith2Params_UnitTest::ConstructL()

   670 	{

   671 	// Perform the base class initialization

   672 	UnitTestConstructL();

   673 

   674 	// Create the Unit test state accessor

   675 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   676 	// Construct the Unit test context.

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

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

   679 	iUTContext->iTestHeader->BeginRawDataL();

   680 	TUint8 octet11 = 0x11; // short int length of 17 bytes

   681 	TUint8 octetA3 = 0xA3; // token for content type

   682 	TUint8 octet97 = 0x97; // token for well-known param Name

   683 	TUint8 octet8E = 0x8E; // token for well-known param Max-age

   684 	TUint8 octet03 = 0x03; // short length of 3

   685 	TUint8 octet255 = 0xFF;

   686 	TUint8 octet254 = 0xFE;

   687 	

   688 	iUTContext->iTestHeader->CommitRawData();

   689 	_LIT8(KTxtParamVal, "testparamvalue\0"); // param value

   690 

   691 	iUTContext->iTestHeader->WriteRawDataL(octet11);

   692 	iUTContext->iTestHeader->WriteRawDataL(octetA3);

   693 	iUTContext->iTestHeader->WriteRawDataL(octet97);

   694 	iUTContext->iTestHeader->WriteRawDataL(KTxtParamVal());

   695 	iUTContext->iTestHeader->WriteRawDataL(octet8E);

   696 	iUTContext->iTestHeader->WriteRawDataL(octet03);

   697 	iUTContext->iTestHeader->WriteRawDataL(octet255);

   698 	iUTContext->iTestHeader->WriteRawDataL(octet255);

   699 	iUTContext->iTestHeader->WriteRawDataL(octet254);

   700 	iUTContext->iTestHeader->CommitRawData();

   701 

   702 	_LIT8(KTxtExpected, "application/vnd.wap.multipart.mixed;Name=testparamvalue;Max-age=16777214");

   703 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   706 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   707 		using constructor and destuctor validators */

   708 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   709 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   710 	iContentTypeWith2ParamsValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   711 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeWith2ParamsValidator));

   712 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   713 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   714 	}

   715 

   716 // ______________________________________________________________________________

   717 //

   718 _LIT(KWspHeaderReaderDateUnitTest,"CWspHeaderReader_Date_UnitTest");

   719 

   720 CWspHeaderReader_Date_UnitTest* CWspHeaderReader_Date_UnitTest::NewL(CDataLogger& aDataLogger,

   721 											MUnitTestObserver& aObserver)

   722 	{

   723 	CWspHeaderReader_Date_UnitTest* self = 

   724 					new(ELeave) CWspHeaderReader_Date_UnitTest(aDataLogger,

   725 																aObserver);

   726 	CleanupStack::PushL(self);

   727 	self->ConstructL();

   728 	CleanupStack::Pop(self);

   729 	return self; 

   730 	}

   731 

   732 inline TInt CWspHeaderReader_Date_UnitTest::RunError(TInt aError)

   733 	{

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

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

   736 	delete iUTContext;

   737 	iUTContext = NULL;

   738 	delete iStateAccessor;

   739 	iStateAccessor = NULL;

   740 	/* delete any validators used */

   741 	delete iCtorValidator;

   742 	iCtorValidator = NULL;

   743 	delete iDateValidator;

   744 	iDateValidator = NULL;

   745 	delete iDtorValidator;

   746 	iDtorValidator = NULL;

   747 	return error;

   748 	}

   749 

   750 inline CWspHeaderReader_Date_UnitTest::~CWspHeaderReader_Date_UnitTest()

   751 	{

   752 	// Simply delete our test class instance

   753 	delete iUTContext;

   754 	delete iStateAccessor;

   755 	/* delete any validators used */

   756 	delete iCtorValidator;

   757 	delete iDateValidator;

   758 	delete iDtorValidator;

   759 	}

   760 

   761 inline CWspHeaderReader_Date_UnitTest::CWspHeaderReader_Date_UnitTest(CDataLogger& aDataLogger,

   762 																	MUnitTestObserver& aObserver)

   763 : CUnitTest(KWspHeaderReaderDateUnitTest, aDataLogger, aObserver)

   764 	{

   765 	//Do nothing

   766 	}

   767 

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

   769 inline void CWspHeaderReader_Date_UnitTest::ConstructL()

   770 	{

   771 	// Perform the base class initialization

   772 	UnitTestConstructL();

   773 

   774 	// Create the Unit test state accessor

   775 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   776 	// Construct the Unit test context.

   777 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   778 	iUTContext->ConstructL(WSP::EDate);

   779 	iUTContext->iTestHeader->BeginRawDataL();

   780 	TUint8 octet03 = 3;

   781 	TUint8 octet255 = 0xFF;

   782 	TUint8 octet254 = 0xFE;

   783 	iUTContext->iTestHeader->WriteRawDataL(octet03);

   784 	iUTContext->iTestHeader->WriteRawDataL(octet255);

   785 	iUTContext->iTestHeader->WriteRawDataL(octet255);

   786 	iUTContext->iTestHeader->WriteRawDataL(octet254);

   787 	iUTContext->iTestHeader->CommitRawData();

   788 	_LIT8(KTxtExpected, "Tue, 14 Jul 1970 04:20:14 GMT");

   789 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   792 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   793 		using constructor and destuctor validators */

   794 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   795 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   796 	iDateValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   797 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iDateValidator));

   798 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   799 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   800 	}

   801 

   802 

   803 

   804 

   805 // ______________________________________________________________________________

   806 //

   807 _LIT(KWspHeaderReaderLastModifiedUnitTest,"CWspHeaderReader_LastModified_UnitTest");

   808 

   809 CWspHeaderReader_LastModified_UnitTest* CWspHeaderReader_LastModified_UnitTest::NewL(CDataLogger& aDataLogger,

   810 											MUnitTestObserver& aObserver)

   811 	{

   812 	CWspHeaderReader_LastModified_UnitTest* self = 

   813 					new(ELeave) CWspHeaderReader_LastModified_UnitTest(aDataLogger,

   814 																aObserver);

   815 	CleanupStack::PushL(self);

   816 	self->ConstructL();

   817 	CleanupStack::Pop(self);

   818 	return self; 

   819 	}

   820 

   821 inline TInt CWspHeaderReader_LastModified_UnitTest::RunError(TInt aError)

   822 	{

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

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

   825 	delete iUTContext;

   826 	iUTContext = NULL;

   827 	delete iStateAccessor;

   828 	iStateAccessor = NULL;

   829 	/* delete any validators used */

   830 	delete iCtorValidator;

   831 	iCtorValidator = NULL;

   832 	delete iLastModifiedValidator;

   833 	iLastModifiedValidator = NULL;

   834 	delete iDtorValidator;

   835 	iDtorValidator = NULL;

   836 	return error;

   837 	}

   838 

   839 inline CWspHeaderReader_LastModified_UnitTest::~CWspHeaderReader_LastModified_UnitTest()

   840 	{

   841 	// Simply delete our test class instance

   842 	delete iUTContext;

   843 	delete iStateAccessor;

   844 	/* delete any validators used */

   845 	delete iCtorValidator;

   846 	delete iLastModifiedValidator;

   847 	delete iDtorValidator;

   848 	}

   849 

   850 inline CWspHeaderReader_LastModified_UnitTest::CWspHeaderReader_LastModified_UnitTest(CDataLogger& aDataLogger,

   851 																	MUnitTestObserver& aObserver)

   852 : CUnitTest(KWspHeaderReaderLastModifiedUnitTest, aDataLogger, aObserver)

   853 	{

   854 	//Do nothing

   855 	}

   856 

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

   858 inline void CWspHeaderReader_LastModified_UnitTest::ConstructL()

   859 	{

   860 	// Perform the base class initialization

   861 	UnitTestConstructL();

   862 

   863 	// Create the Unit test state accessor

   864 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   865 	// Construct the Unit test context.

   866 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   867 	iUTContext->ConstructL(WSP::ELastModified);

   868 	iUTContext->iTestHeader->BeginRawDataL();

   869 	TUint8 octet03 = 3;

   870 	TUint8 octet255 = 0xFF;

   871 	TUint8 octet254 = 0xFE;

   872 	iUTContext->iTestHeader->WriteRawDataL(octet03);

   873 	iUTContext->iTestHeader->WriteRawDataL(octet255);

   874 	iUTContext->iTestHeader->WriteRawDataL(octet255);

   875 	iUTContext->iTestHeader->WriteRawDataL(octet254);

   876 	iUTContext->iTestHeader->CommitRawData();

   877 	_LIT8(KTxtExpected, "Tue, 14 Jul 1970 04:20:14 GMT");

   878 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   881 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   882 		using constructor and destuctor validators */

   883 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   884 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   885 	iLastModifiedValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   886 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iLastModifiedValidator));

   887 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   888 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   889 	}

   890 

   891 // ______________________________________________________________________________

   892 //

   893 _LIT(KWspHeaderReaderPragmaNoCacheUnitTest,"CWspHeaderReader_PragmaNoCache_UnitTest");

   894 

   895 CWspHeaderReader_PragmaNoCache_UnitTest* CWspHeaderReader_PragmaNoCache_UnitTest::NewL(CDataLogger& aDataLogger,

   896 											MUnitTestObserver& aObserver)

   897 	{

   898 	CWspHeaderReader_PragmaNoCache_UnitTest* self = 

   899 					new(ELeave) CWspHeaderReader_PragmaNoCache_UnitTest(aDataLogger,

   900 																aObserver);

   901 	CleanupStack::PushL(self);

   902 	self->ConstructL();

   903 	CleanupStack::Pop(self);

   904 	return self; 

   905 	}

   906 

   907 inline TInt CWspHeaderReader_PragmaNoCache_UnitTest::RunError(TInt aError)

   908 	{

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

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

   911 	delete iUTContext;

   912 	iUTContext = NULL;

   913 	delete iStateAccessor;

   914 	iStateAccessor = NULL;

   915 	/* delete any validators used */

   916 	delete iCtorValidator;

   917 	iCtorValidator = NULL;

   918 	delete iPragmaNoCacheValidator;

   919 	iPragmaNoCacheValidator = NULL;

   920 	delete iDtorValidator;

   921 	iDtorValidator = NULL;

   922 	return error;

   923 	}

   924 

   925 inline CWspHeaderReader_PragmaNoCache_UnitTest::~CWspHeaderReader_PragmaNoCache_UnitTest()

   926 	{

   927 	// Simply delete our test class instance

   928 	delete iUTContext;

   929 	delete iStateAccessor;

   930 	/* delete any validators used */

   931 	delete iCtorValidator;

   932 	delete iPragmaNoCacheValidator;

   933 	delete iDtorValidator;

   934 	}

   935 

   936 inline CWspHeaderReader_PragmaNoCache_UnitTest::CWspHeaderReader_PragmaNoCache_UnitTest(CDataLogger& aDataLogger,

   937 																	MUnitTestObserver& aObserver)

   938 : CUnitTest(KWspHeaderReaderPragmaNoCacheUnitTest, aDataLogger, aObserver)

   939 	{

   940 	//Do nothing

   941 	}

   942 

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

   944 inline void CWspHeaderReader_PragmaNoCache_UnitTest::ConstructL()

   945 	{

   946 	// Perform the base class initialization

   947 	UnitTestConstructL();

   948 

   949 	// Create the Unit test state accessor

   950 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

   951 	// Construct the Unit test context.

   952 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

   953 	iUTContext->ConstructL(WSP::EPragma);

   954 	iUTContext->iTestHeader->BeginRawDataL();

   955 	TUint8 octet80 = 0x80;

   956 	iUTContext->iTestHeader->WriteRawDataL(octet80);

   957 	iUTContext->iTestHeader->CommitRawData();

   958 	_LIT8(KTxtExpected, "No-cache");

   959 	iUTContext->SetExpectedL(KTxtExpected());

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

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

   962 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

   963 		using constructor and destuctor validators */

   964 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

   965 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

   966 	iPragmaNoCacheValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

   967 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iPragmaNoCacheValidator));

   968 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

   969 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

   970 	}

   971 

   972 // ______________________________________________________________________________

   973 //

   974 _LIT(KWspHeaderReaderPragmaTokenParamUnitTest,"CWspHeaderReader_PragmaTokenParam_UnitTest");

   975 

   976 CWspHeaderReader_PragmaTokenParam_UnitTest* CWspHeaderReader_PragmaTokenParam_UnitTest::NewL(CDataLogger& aDataLogger,

   977 											MUnitTestObserver& aObserver)

   978 	{

   979 	CWspHeaderReader_PragmaTokenParam_UnitTest* self = 

   980 					new(ELeave) CWspHeaderReader_PragmaTokenParam_UnitTest(aDataLogger,

   981 																aObserver);

   982 	CleanupStack::PushL(self);

   983 	self->ConstructL();

   984 	CleanupStack::Pop(self);

   985 	return self; 

   986 	}

   987 

   988 inline TInt CWspHeaderReader_PragmaTokenParam_UnitTest::RunError(TInt aError)

   989 	{

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

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

   992 	delete iUTContext;

   993 	iUTContext = NULL;

   994 	delete iStateAccessor;

   995 	iStateAccessor = NULL;

   996 	/* delete any validators used */

   997 	delete iCtorValidator;

   998 	iCtorValidator = NULL;

   999 	delete iPragmaTokenParamValidator;

  1000 	iPragmaTokenParamValidator = NULL;

  1001 	delete iDtorValidator;

  1002 	iDtorValidator = NULL;

  1003 	return error;

  1004 	}

  1005 

  1006 inline CWspHeaderReader_PragmaTokenParam_UnitTest::~CWspHeaderReader_PragmaTokenParam_UnitTest()

  1007 	{

  1008 	// Simply delete our test class instance

  1009 	delete iUTContext;

  1010 	delete iStateAccessor;

  1011 	/* delete any validators used */

  1012 	delete iCtorValidator;

  1013 	delete iPragmaTokenParamValidator;

  1014 	delete iDtorValidator;

  1015 	}

  1016 

  1017 inline CWspHeaderReader_PragmaTokenParam_UnitTest::CWspHeaderReader_PragmaTokenParam_UnitTest(CDataLogger& aDataLogger,

  1018 																	MUnitTestObserver& aObserver)

  1019 : CUnitTest(KWspHeaderReaderPragmaTokenParamUnitTest, aDataLogger, aObserver)

  1020 	{

  1021 	//Do nothing

  1022 	}

  1023 

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

  1025 inline void CWspHeaderReader_PragmaTokenParam_UnitTest::ConstructL()

  1026 	{

  1027 	// Perform the base class initialization

  1028 	UnitTestConstructL();

  1029 

  1030 	// Create the Unit test state accessor

  1031 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

  1032 	// Construct the Unit test context.

  1033 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

  1034 	iUTContext->ConstructL(WSP::EPragma);

  1035 	iUTContext->iTestHeader->BeginRawDataL();

  1036 	TUint8 octet18 = 0x18; // short int for the length of the data

  1037 	_LIT8(KTxtParamName, "ExampleParam\0");

  1038 	_LIT8(KTxtParamValue, "paramvalue\0");

  1039 	iUTContext->iTestHeader->WriteRawDataL(octet18);

  1040 	iUTContext->iTestHeader->WriteRawDataL(KTxtParamName());

  1041 	iUTContext->iTestHeader->WriteRawDataL(KTxtParamValue());

  1042 	iUTContext->iTestHeader->CommitRawData();

  1043 	_LIT8(KTxtExpected, ";ExampleParam=paramvalue");

  1044 	iUTContext->SetExpectedL(KTxtExpected());

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

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

  1047 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

  1048 		using constructor and destuctor validators */

  1049 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

  1050 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));

  1051 	iPragmaTokenParamValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);

  1052 	AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iPragmaTokenParamValidator));

  1053 	iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);

  1054 	AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));

  1055 	}

  1056 

  1057 // ______________________________________________________________________________

  1058 //

  1059 _LIT(KWspHeaderReaderPragmaTokenParamNoValueUnitTest,"CWspHeaderReader_PragmaTokenParamNoValue_UnitTest");

  1060 

  1061 CWspHeaderReader_PragmaTokenParamNoValue_UnitTest* CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::NewL(CDataLogger& aDataLogger,

  1062 											MUnitTestObserver& aObserver)

  1063 	{

  1064 	CWspHeaderReader_PragmaTokenParamNoValue_UnitTest* self = 

  1065 					new(ELeave) CWspHeaderReader_PragmaTokenParamNoValue_UnitTest(aDataLogger,

  1066 																aObserver);

  1067 	CleanupStack::PushL(self);

  1068 	self->ConstructL();

  1069 	CleanupStack::Pop(self);

  1070 	return self; 

  1071 	}

  1072 

  1073 inline TInt CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::RunError(TInt aError)

  1074 	{

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

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

  1077 	delete iUTContext;

  1078 	iUTContext = NULL;

  1079 	delete iStateAccessor;

  1080 	iStateAccessor = NULL;

  1081 	/* delete any validators used */

  1082 	delete iCtorValidator;

  1083 	iCtorValidator = NULL;

  1084 	delete iPragmaTokenParamNoValueValidator;

  1085 	iPragmaTokenParamNoValueValidator = NULL;

  1086 	delete iDtorValidator;

  1087 	iDtorValidator = NULL;

  1088 	return error;

  1089 	}

  1090 

  1091 inline CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::~CWspHeaderReader_PragmaTokenParamNoValue_UnitTest()

  1092 	{

  1093 	// Simply delete our test class instance

  1094 	delete iUTContext;

  1095 	delete iStateAccessor;

  1096 	/* delete any validators used */

  1097 	delete iCtorValidator;

  1098 	delete iPragmaTokenParamNoValueValidator;

  1099 	delete iDtorValidator;

  1100 	}

  1101 

  1102 inline CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::CWspHeaderReader_PragmaTokenParamNoValue_UnitTest(CDataLogger& aDataLogger,

  1103 																	MUnitTestObserver& aObserver)

  1104 : CUnitTest(KWspHeaderReaderPragmaTokenParamNoValueUnitTest, aDataLogger, aObserver)

  1105 	{

  1106 	//Do nothing

  1107 	}

  1108 

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

  1110 inline void CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::ConstructL()

  1111 	{

  1112 	// Perform the base class initialization

  1113 	UnitTestConstructL();

  1114 

  1115 	// Create the Unit test state accessor

  1116 	iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;

  1117 	// Construct the Unit test context.

  1118 	iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);

  1119 	iUTContext->ConstructL(WSP::EPragma);

  1120 	iUTContext->iTestHeader->BeginRawDataL();

  1121 	TUint8 octet0E = 0x0E; // short int for the length of the data

  1122 	_LIT8(KTxtParamName, "ExampleParam\0");

  1123 	TUint8 octet00 = 0x00; // null terminator

  1124 	iUTContext->iTestHeader->WriteRawDataL(octet0E);

  1125 	iUTContext->iTestHeader->WriteRawDataL(KTxtParamName());

  1126 	iUTContext->iTestHeader->WriteRawDataL(octet00);

  1127 	iUTContext->iTestHeader->CommitRawData();

  1128 	_LIT8(KTxtExpected, ";ExampleParam");

  1129 	iUTContext->SetExpectedL(KTxtExpected());

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

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

  1132 	/*	Examples of C'tor and D'tor transitions on CWspHeaderReader class.

  1133 		using constructor and destuctor validators */

  1134 	iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);

  1135 	AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));