--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httptransportfw/Test/T_WspDecoder/WspHeaderReaderUnitTest.cpp Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,8225 @@
+// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// The unit test class implementations for the CWspHeaderReader class.
+//
+//
+
+/**
+ @file WspHeaderReaderUnitTest.cpp
+*/
+
+#include "WspHeaderReaderUnitTest.h"
+
+// System includes
+#include <wspstringconstants.h>
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderCreateAndDestroyUnitTest,"CWspHeaderReader_CreateAndDestroy_UnitTest");
+
+CWspHeaderReader_CreateAndDestroy_UnitTest* CWspHeaderReader_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_CreateAndDestroy_UnitTest* self =
+ new(ELeave) CWspHeaderReader_CreateAndDestroy_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_CreateAndDestroy_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_CreateAndDestroy_UnitTest::~CWspHeaderReader_CreateAndDestroy_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_CreateAndDestroy_UnitTest::CWspHeaderReader_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderCreateAndDestroyUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_CreateAndDestroy_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAccept);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeShortTokenUnitTest,"CWspHeaderReader_ContentTypeShortToken_UnitTest");
+
+CWspHeaderReader_ContentTypeShortToken_UnitTest* CWspHeaderReader_ContentTypeShortToken_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeShortToken_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeShortToken_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeShortToken_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeShortTokenValidator;
+ iContentTypeShortTokenValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeShortToken_UnitTest::~CWspHeaderReader_ContentTypeShortToken_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeShortTokenValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeShortToken_UnitTest::CWspHeaderReader_ContentTypeShortToken_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeShortTokenUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeShortToken_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet81 = 0x81; // Should be token value for text/*
+ iUTContext->iTestHeader->WriteRawDataL(octet81);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "text/*");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeShortTokenValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeShortTokenValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeExtensionMediaUnitTest,"CWspHeaderReader_ContentTypeExtensionMedia_UnitTest");
+
+CWspHeaderReader_ContentTypeExtensionMedia_UnitTest* CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeExtensionMedia_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeExtensionMedia_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeExtensionMediaValidator;
+ iContentTypeExtensionMediaValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::~CWspHeaderReader_ContentTypeExtensionMedia_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeExtensionMediaValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::CWspHeaderReader_ContentTypeExtensionMedia_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeExtensionMediaUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeExtensionMedia_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtData, "extension/media\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtData());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "extension/media");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeExtensionMediaValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeExtensionMediaValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeNullUnitTest,"CWspHeaderReader_ContentTypeNull_UnitTest");
+
+CWspHeaderReader_ContentTypeNull_UnitTest* CWspHeaderReader_ContentTypeNull_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeNull_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeNull_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeNull_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeNullValidator;
+ iContentTypeNullValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeNull_UnitTest::~CWspHeaderReader_ContentTypeNull_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeNullValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeNull_UnitTest::CWspHeaderReader_ContentTypeNull_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeNullUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeNull_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet00 = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeNullValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeNullValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeWellKnownMediaIntUnitTest,"CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest");
+
+CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest* CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeWellKnownMediaIntValidator;
+ iContentTypeWellKnownMediaIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::~CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeWellKnownMediaIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeWellKnownMediaIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeWellKnownMediaInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet02 = 0x02;
+ TUint8 octet03 = 0x03;
+ TUint8 octet0B = 0x0B;
+ iUTContext->iTestHeader->WriteRawDataL(octet03);
+ iUTContext->iTestHeader->WriteRawDataL(octet02);
+ iUTContext->iTestHeader->WriteRawDataL(octet02);
+ iUTContext->iTestHeader->WriteRawDataL(octet0B);
+
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "application/vnd.nokia.syncset+wbxml");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeWellKnownMediaIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeWellKnownMediaIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeMediaTypeExtensionUnitTest,"CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest");
+
+CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest* CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeMediaTypeExtensionValidator;
+ iContentTypeMediaTypeExtensionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::~CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeMediaTypeExtensionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeMediaTypeExtensionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeMediaTypeExtension_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+
+ TUint8 octet1F = 0x1F; // <Octet 31> for length quote
+ TUint8 octet82 = 0x82;
+ TUint8 octet2D = 0x2D;
+ TUint8 octet00 = 0x00; // NULL terminator
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(octet82);
+ iUTContext->iTestHeader->WriteRawDataL(octet2D);
+ _LIT8(KTxt10ByteData, "tenbyteapp");
+ for( TInt i=0; i<30; ++i )
+ {
+ iUTContext->iTestHeader->WriteRawDataL(KTxt10ByteData());
+ }
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+
+ HBufC8* buf = HBufC8::NewL(300);
+ CleanupStack::PushL(buf);
+ TPtr8 appendBuf(buf->Des());
+ for( TInt i=0; i<30; ++i )
+ {
+ appendBuf.Append(KTxt10ByteData());
+ }
+ iUTContext->SetExpectedL(*buf);
+ CleanupStack::PopAndDestroy(buf);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeMediaTypeExtensionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeMediaTypeExtensionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeWith1ParamUnitTest,"CWspHeaderReader_ContentTypeWith1Param_UnitTest");
+
+CWspHeaderReader_ContentTypeWith1Param_UnitTest* CWspHeaderReader_ContentTypeWith1Param_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeWith1Param_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeWith1Param_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeWith1Param_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeWith1ParamValidator;
+ iContentTypeWith1ParamValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeWith1Param_UnitTest::~CWspHeaderReader_ContentTypeWith1Param_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeWith1ParamValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeWith1Param_UnitTest::CWspHeaderReader_ContentTypeWith1Param_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeWith1ParamUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeWith1Param_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet11 = 0x11; // short int length of 17 bytes
+ TUint8 octetA3 = 0xA3; // token for content type
+ TUint8 octet97 = 0x97; // token for well-known param
+ _LIT8(KTxtParamVal, "testparamvalue\0"); // param value
+
+ iUTContext->iTestHeader->WriteRawDataL(octet11);
+ iUTContext->iTestHeader->WriteRawDataL(octetA3);
+ iUTContext->iTestHeader->WriteRawDataL(octet97);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParamVal());
+ iUTContext->iTestHeader->CommitRawData();
+
+ _LIT8(KTxtExpected, "application/vnd.wap.multipart.mixed;Name=testparamvalue");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeWith1ParamValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeWith1ParamValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentTypeWith2ParamsUnitTest,"CWspHeaderReader_ContentTypeWith2Params_UnitTest");
+
+CWspHeaderReader_ContentTypeWith2Params_UnitTest* CWspHeaderReader_ContentTypeWith2Params_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentTypeWith2Params_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentTypeWith2Params_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentTypeWith2Params_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentTypeWith2ParamsValidator;
+ iContentTypeWith2ParamsValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentTypeWith2Params_UnitTest::~CWspHeaderReader_ContentTypeWith2Params_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentTypeWith2ParamsValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentTypeWith2Params_UnitTest::CWspHeaderReader_ContentTypeWith2Params_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentTypeWith2ParamsUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentTypeWith2Params_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentType);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet11 = 0x11; // short int length of 17 bytes
+ TUint8 octetA3 = 0xA3; // token for content type
+ TUint8 octet97 = 0x97; // token for well-known param Name
+ TUint8 octet8E = 0x8E; // token for well-known param Max-age
+ TUint8 octet03 = 0x03; // short length of 3
+ TUint8 octet255 = 0xFF;
+ TUint8 octet254 = 0xFE;
+
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtParamVal, "testparamvalue\0"); // param value
+
+ iUTContext->iTestHeader->WriteRawDataL(octet11);
+ iUTContext->iTestHeader->WriteRawDataL(octetA3);
+ iUTContext->iTestHeader->WriteRawDataL(octet97);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParamVal());
+ iUTContext->iTestHeader->WriteRawDataL(octet8E);
+ iUTContext->iTestHeader->WriteRawDataL(octet03);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+
+ _LIT8(KTxtExpected, "application/vnd.wap.multipart.mixed;Name=testparamvalue;Max-age=16777214");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentTypeWith2ParamsValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentTypeWith2ParamsValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderDateUnitTest,"CWspHeaderReader_Date_UnitTest");
+
+CWspHeaderReader_Date_UnitTest* CWspHeaderReader_Date_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_Date_UnitTest* self =
+ new(ELeave) CWspHeaderReader_Date_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_Date_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iDateValidator;
+ iDateValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_Date_UnitTest::~CWspHeaderReader_Date_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iDateValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_Date_UnitTest::CWspHeaderReader_Date_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderDateUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_Date_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EDate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet03 = 3;
+ TUint8 octet255 = 0xFF;
+ TUint8 octet254 = 0xFE;
+ iUTContext->iTestHeader->WriteRawDataL(octet03);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Tue, 14 Jul 1970 04:20:14 GMT");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iDateValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iDateValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+
+
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderLastModifiedUnitTest,"CWspHeaderReader_LastModified_UnitTest");
+
+CWspHeaderReader_LastModified_UnitTest* CWspHeaderReader_LastModified_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_LastModified_UnitTest* self =
+ new(ELeave) CWspHeaderReader_LastModified_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_LastModified_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iLastModifiedValidator;
+ iLastModifiedValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_LastModified_UnitTest::~CWspHeaderReader_LastModified_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iLastModifiedValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_LastModified_UnitTest::CWspHeaderReader_LastModified_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderLastModifiedUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_LastModified_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ELastModified);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet03 = 3;
+ TUint8 octet255 = 0xFF;
+ TUint8 octet254 = 0xFE;
+ iUTContext->iTestHeader->WriteRawDataL(octet03);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Tue, 14 Jul 1970 04:20:14 GMT");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iLastModifiedValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iLastModifiedValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderPragmaNoCacheUnitTest,"CWspHeaderReader_PragmaNoCache_UnitTest");
+
+CWspHeaderReader_PragmaNoCache_UnitTest* CWspHeaderReader_PragmaNoCache_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_PragmaNoCache_UnitTest* self =
+ new(ELeave) CWspHeaderReader_PragmaNoCache_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_PragmaNoCache_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iPragmaNoCacheValidator;
+ iPragmaNoCacheValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_PragmaNoCache_UnitTest::~CWspHeaderReader_PragmaNoCache_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iPragmaNoCacheValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_PragmaNoCache_UnitTest::CWspHeaderReader_PragmaNoCache_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderPragmaNoCacheUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_PragmaNoCache_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EPragma);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet80 = 0x80;
+ iUTContext->iTestHeader->WriteRawDataL(octet80);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "No-cache");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iPragmaNoCacheValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iPragmaNoCacheValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderPragmaTokenParamUnitTest,"CWspHeaderReader_PragmaTokenParam_UnitTest");
+
+CWspHeaderReader_PragmaTokenParam_UnitTest* CWspHeaderReader_PragmaTokenParam_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_PragmaTokenParam_UnitTest* self =
+ new(ELeave) CWspHeaderReader_PragmaTokenParam_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_PragmaTokenParam_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iPragmaTokenParamValidator;
+ iPragmaTokenParamValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_PragmaTokenParam_UnitTest::~CWspHeaderReader_PragmaTokenParam_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iPragmaTokenParamValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_PragmaTokenParam_UnitTest::CWspHeaderReader_PragmaTokenParam_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderPragmaTokenParamUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_PragmaTokenParam_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EPragma);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet18 = 0x18; // short int for the length of the data
+ _LIT8(KTxtParamName, "ExampleParam\0");
+ _LIT8(KTxtParamValue, "paramvalue\0");
+ iUTContext->iTestHeader->WriteRawDataL(octet18);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParamName());
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParamValue());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, ";ExampleParam=paramvalue");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iPragmaTokenParamValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iPragmaTokenParamValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderPragmaTokenParamNoValueUnitTest,"CWspHeaderReader_PragmaTokenParamNoValue_UnitTest");
+
+CWspHeaderReader_PragmaTokenParamNoValue_UnitTest* CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_PragmaTokenParamNoValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_PragmaTokenParamNoValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iPragmaTokenParamNoValueValidator;
+ iPragmaTokenParamNoValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::~CWspHeaderReader_PragmaTokenParamNoValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iPragmaTokenParamNoValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::CWspHeaderReader_PragmaTokenParamNoValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderPragmaTokenParamNoValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_PragmaTokenParamNoValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EPragma);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet0E = 0x0E; // short int for the length of the data
+ _LIT8(KTxtParamName, "ExampleParam\0");
+ TUint8 octet00 = 0x00; // null terminator
+ iUTContext->iTestHeader->WriteRawDataL(octet0E);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParamName());
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, ";ExampleParam");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iPragmaTokenParamNoValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iPragmaTokenParamNoValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderVaryShortIntTokenUnitTest,"CWspHeaderReader_VaryShortIntToken_UnitTest");
+
+CWspHeaderReader_VaryShortIntToken_UnitTest* CWspHeaderReader_VaryShortIntToken_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_VaryShortIntToken_UnitTest* self =
+ new(ELeave) CWspHeaderReader_VaryShortIntToken_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_VaryShortIntToken_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iVaryShortIntTokenValidator;
+ iVaryShortIntTokenValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_VaryShortIntToken_UnitTest::~CWspHeaderReader_VaryShortIntToken_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iVaryShortIntTokenValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_VaryShortIntToken_UnitTest::CWspHeaderReader_VaryShortIntToken_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderVaryShortIntTokenUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_VaryShortIntToken_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EVary);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet91 = 0x91;
+ iUTContext->iTestHeader->WriteRawDataL(octet91);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Content-type");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iVaryShortIntTokenValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iVaryShortIntTokenValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderVaryTokenTextUnitTest,"CWspHeaderReader_VaryTokenText_UnitTest");
+
+CWspHeaderReader_VaryTokenText_UnitTest* CWspHeaderReader_VaryTokenText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_VaryTokenText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_VaryTokenText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_VaryTokenText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iVaryTokenTextValidator;
+ iVaryTokenTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_VaryTokenText_UnitTest::~CWspHeaderReader_VaryTokenText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iVaryTokenTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_VaryTokenText_UnitTest::CWspHeaderReader_VaryTokenText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderVaryTokenTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_VaryTokenText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EVary);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtTokenText, "Vary-Token-Text\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTokenText());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Vary-Token-Text");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iVaryTokenTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iVaryTokenTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWWWAuthenticateBasicUnitTest,"CWspHeaderReader_WWWAuthenticateBasic_UnitTest");
+
+CWspHeaderReader_WWWAuthenticateBasic_UnitTest* CWspHeaderReader_WWWAuthenticateBasic_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WWWAuthenticateBasic_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WWWAuthenticateBasic_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WWWAuthenticateBasic_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWWWAuthenticateBasicValidator;
+ iWWWAuthenticateBasicValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateBasic_UnitTest::~CWspHeaderReader_WWWAuthenticateBasic_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWWWAuthenticateBasicValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateBasic_UnitTest::CWspHeaderReader_WWWAuthenticateBasic_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWWWAuthenticateBasicUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WWWAuthenticateBasic_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWWWAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet0D = 0x0D; // short length octet for 13 bytes
+ TUint8 octet80 = 0x80; // <octet 128> token for basic
+ _LIT8(KTxtRealm, "Realm-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(octet0D);
+ iUTContext->iTestHeader->WriteRawDataL(octet80);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtRealm());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Basic,Realm-value");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWWWAuthenticateBasicValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWWWAuthenticateBasicValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWWWAuthenticateBasicWithoutRealmUnitTest,"CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest");
+
+CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest* CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWWWAuthenticateBasicWithoutRealmValidator;
+ iWWWAuthenticateBasicWithoutRealmValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest::~CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWWWAuthenticateBasicWithoutRealmValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest::CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWWWAuthenticateBasicWithoutRealmUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WWWAuthenticateBasicWithoutRealm_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWWWAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet02 = 0x02; // short length octet for 13 bytes
+ TUint8 octet80 = 0x80; // <octet 128> token for basic
+ TUint8 octet00 = 0x00; // <octet 0> for null terminate
+ iUTContext->iTestHeader->WriteRawDataL(octet02);
+ iUTContext->iTestHeader->WriteRawDataL(octet80);
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Basic,");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWWWAuthenticateBasicWithoutRealmValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWWWAuthenticateBasicWithoutRealmValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWWWAuthenticateAuthSchemeUnitTest,"CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest");
+
+CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest* CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWWWAuthenticateAuthSchemeValidator;
+ iWWWAuthenticateAuthSchemeValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest::~CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWWWAuthenticateAuthSchemeValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest::CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWWWAuthenticateAuthSchemeUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WWWAuthenticateAuthScheme_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWWWAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet1F = 0x1F; // length quote <octet 31>
+ _LIT8(KTxtScheme, "Authenicate-scheme\0");
+ _LIT8(KTxtRealm, "Realm-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(octet1F); // 31 bytes uintvar-value
+ iUTContext->iTestHeader->WriteRawDataL(KTxtScheme);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtRealm);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Authenicate-scheme,Realm-value");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWWWAuthenticateAuthSchemeValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWWWAuthenticateAuthSchemeValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWWWAuthenticateAuthSchemeNoRealmUnitTest,"CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest");
+
+CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest* CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWWWAuthenticateAuthSchemeNoRealmValidator;
+ iWWWAuthenticateAuthSchemeNoRealmValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest::~CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWWWAuthenticateAuthSchemeNoRealmValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest::CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWWWAuthenticateAuthSchemeNoRealmUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWWWAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet14 = 0x14; // short length of 20 bytes
+ _LIT8(KTxtScheme, "Authenicate-scheme\0");
+ TUint8 octet00 = 0x00; // null terminate <octet 0>
+ iUTContext->iTestHeader->WriteRawDataL(octet14);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtScheme);
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Authenicate-scheme,");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWWWAuthenticateAuthSchemeNoRealmValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWWWAuthenticateAuthSchemeNoRealmValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWWWAuthenticateAuthScheme2ParamsUnitTest,"CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest");
+
+CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest* CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWWWAuthenticateAuthScheme2ParamsValidator;
+ iWWWAuthenticateAuthScheme2ParamsValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest::~CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWWWAuthenticateAuthScheme2ParamsValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest::CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWWWAuthenticateAuthScheme2ParamsUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WWWAuthenticateAuthScheme2Params_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWWWAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet1F = 0x1F; // length quote <octet 31>
+ TUint8 octet3B = 0x3B; // uintvar of 59 bytes
+ _LIT8(KTxtScheme, "Authenicate-scheme\0");
+ _LIT8(KTxtRealm, "Realm-value\0");
+ _LIT8(KTxtParam1Name, "Param1-name\0");
+ _LIT8(KTxtParam1Val, "value\0");
+ TUint8 octet9C = 0x9C; // Token for domain
+ _LIT8(KTxtDomain, "mydomain\0");
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(octet3B);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtScheme);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtRealm);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParam1Name);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParam1Val);
+ iUTContext->iTestHeader->WriteRawDataL(octet9C);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtDomain);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Authenicate-scheme,Realm-value;Param1-name=value;Domain=mydomain");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWWWAuthenticateAuthScheme2ParamsValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWWWAuthenticateAuthScheme2ParamsValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWWWAuthenticateAuthSchemeNoRealm2ParamsUnitTest,"CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest");
+
+CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest* CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWWWAuthenticateAuthSchemeNoRealm2ParamsValidator;
+ iWWWAuthenticateAuthSchemeNoRealm2ParamsValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest::~CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWWWAuthenticateAuthSchemeNoRealm2ParamsValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest::CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWWWAuthenticateAuthSchemeNoRealm2ParamsUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WWWAuthenticateAuthSchemeNoRealm2Params_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWWWAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet1F = 0x1F; // length quote <octet 31>
+ TUint8 octet28 = 0x28; // uintvar of 40 bytes
+ _LIT8(KTxtScheme, "Authenicate-scheme\0");
+ TUint8 octet00 = 0x00; // null terminate
+ _LIT8(KTxtParam1Name, "Param1-name\0");
+ _LIT8(KTxtParam1Val, "value\0");
+ TUint8 octet9C = 0x9C; // Token for domain
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(octet28);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtScheme);
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParam1Name);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtParam1Val);
+ iUTContext->iTestHeader->WriteRawDataL(octet9C);
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Authenicate-scheme,;Param1-name=value;Domain");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWWWAuthenticateAuthSchemeNoRealm2ParamsValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWWWAuthenticateAuthSchemeNoRealm2ParamsValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderSetCookieShortIntVersionUnitTest,"CWspHeaderReader_SetCookieShortIntVersion_UnitTest");
+
+CWspHeaderReader_SetCookieShortIntVersion_UnitTest* CWspHeaderReader_SetCookieShortIntVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_SetCookieShortIntVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_SetCookieShortIntVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_SetCookieShortIntVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iSetCookieShortIntVersionValidator;
+ iSetCookieShortIntVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_SetCookieShortIntVersion_UnitTest::~CWspHeaderReader_SetCookieShortIntVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iSetCookieShortIntVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_SetCookieShortIntVersion_UnitTest::CWspHeaderReader_SetCookieShortIntVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderSetCookieShortIntVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_SetCookieShortIntVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ESetCookie);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet18 = 0x18; // short value for 24 bytes
+ TUint8 version = 0x91; // version 1.1
+ _LIT8(KTxtCookieName, "My-cookie\0");
+ _LIT8(KTxtCookieVal, "Cookie-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(octet18);
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtCookieName);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtCookieVal);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1.1,My-cookie,Cookie-value");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iSetCookieShortIntVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iSetCookieShortIntVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderSetCookieMajorVersionNullName1ParamUnitTest,"CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest");
+
+CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest* CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest* self =
+ new(ELeave) CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iSetCookieMajorVersionNullName1ParamValidator;
+ iSetCookieMajorVersionNullName1ParamValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest::~CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iSetCookieMajorVersionNullName1ParamValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest::CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderSetCookieMajorVersionNullName1ParamUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_SetCookieMajorVersionNullName1Param_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ESetCookie);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet18 = 0x11; // short value for 17 bytes
+ TUint8 version = 0x9F; // version 1
+ TUint8 cookieName = 0x00;
+ _LIT8(KTxtCookieVal, "Cookie-value\0");
+ TUint8 paramToken = 0x87;
+ TUint8 paramValue = 0xC7;
+ iUTContext->iTestHeader->WriteRawDataL(octet18);
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->WriteRawDataL(cookieName);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtCookieVal);
+ iUTContext->iTestHeader->WriteRawDataL(paramToken);
+ iUTContext->iTestHeader->WriteRawDataL(paramValue);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1,,Cookie-value;Differences=Cache-control");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iSetCookieMajorVersionNullName1ParamValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iSetCookieMajorVersionNullName1ParamValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderSetCookieTextVersionNullValueUnitTest,"CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest");
+
+CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest* CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iSetCookieTextVersionNullValueValidator;
+ iSetCookieTextVersionNullValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest::~CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iSetCookieTextVersionNullValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest::CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderSetCookieTextVersionNullValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_SetCookieTextVersionNullValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ESetCookie);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x12; // short value for 18 bytes
+ _LIT8(KTxtVersion, "13.6\0"); // version
+ _LIT8(KTxtCookieName, "My-cookie\0");
+ TUint8 cookieVal = 0x00;
+ TUint8 paramValue1 = 0x83;
+ TUint8 paramValue2 = 0x31;
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtVersion);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtCookieName);
+ iUTContext->iTestHeader->WriteRawDataL(cookieVal);
+ iUTContext->iTestHeader->WriteRawDataL(cookieVal);
+ iUTContext->iTestHeader->WriteRawDataL(paramValue1);
+ iUTContext->iTestHeader->WriteRawDataL(paramValue2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "13.6,My-cookie,;Q=0.333");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iSetCookieTextVersionNullValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iSetCookieTextVersionNullValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderSetCookieNullVersionUnitTest,"CWspHeaderReader_SetCookieNullVersion_UnitTest");
+
+CWspHeaderReader_SetCookieNullVersion_UnitTest* CWspHeaderReader_SetCookieNullVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_SetCookieNullVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_SetCookieNullVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_SetCookieNullVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iSetCookieNullVersionValidator;
+ iSetCookieNullVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_SetCookieNullVersion_UnitTest::~CWspHeaderReader_SetCookieNullVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iSetCookieNullVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_SetCookieNullVersion_UnitTest::CWspHeaderReader_SetCookieNullVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderSetCookieNullVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_SetCookieNullVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ESetCookie);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x1A; // short value for 26 bytes
+ TUint8 version = 0x00;
+ _LIT8(KTxtCookieName, "My-cookie\0");
+ _LIT8(KTxtCookieValue, "cookie-value\0");
+ TUint8 paramName = 0x82;
+ TUint8 paramValue = 0x85;
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtCookieName);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtCookieValue);
+ iUTContext->iTestHeader->WriteRawDataL(paramName);
+ iUTContext->iTestHeader->WriteRawDataL(paramValue);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, ",My-cookie,cookie-value;Level=0.5");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iSetCookieNullVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iSetCookieNullVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLocationUnitTest,"CWspHeaderReader_ContentLocation_UnitTest");
+
+CWspHeaderReader_ContentLocation_UnitTest* CWspHeaderReader_ContentLocation_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLocation_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLocation_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLocation_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLocationValidator;
+ iContentLocationValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLocation_UnitTest::~CWspHeaderReader_ContentLocation_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLocationValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLocation_UnitTest::CWspHeaderReader_ContentLocation_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLocationUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLocation_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLocation);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 wspQuote = 0x7F; // WSP quote char
+ _LIT8(KTxtString, "http://www.symbian.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(wspQuote);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtString);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "http://www.symbian.com");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLocationValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentLocationValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderLocationWithoutQuoteUnitTest,"CWspHeaderReader_LocationWithoutQuote_UnitTest");
+
+CWspHeaderReader_LocationWithoutQuote_UnitTest* CWspHeaderReader_LocationWithoutQuote_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_LocationWithoutQuote_UnitTest* self =
+ new(ELeave) CWspHeaderReader_LocationWithoutQuote_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_LocationWithoutQuote_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iLocationWithoutQuoteValidator;
+ iLocationWithoutQuoteValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_LocationWithoutQuote_UnitTest::~CWspHeaderReader_LocationWithoutQuote_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iLocationWithoutQuoteValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_LocationWithoutQuote_UnitTest::CWspHeaderReader_LocationWithoutQuote_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderLocationWithoutQuoteUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_LocationWithoutQuote_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLocation);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtString, "http://www.symbian.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtString);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "http://www.symbian.com");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iLocationWithoutQuoteValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iLocationWithoutQuoteValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionShortIntUnitTest,"CWspHeaderReader_EncodingVersionShortInt_UnitTest");
+
+CWspHeaderReader_EncodingVersionShortInt_UnitTest* CWspHeaderReader_EncodingVersionShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionShortIntValidator;
+ iEncodingVersionShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionShortInt_UnitTest::~CWspHeaderReader_EncodingVersionShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionShortInt_UnitTest::CWspHeaderReader_EncodingVersionShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 version = 0x91;
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1.1");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionNullVersionUnitTest,"CWspHeaderReader_EncodingVersionNullVersion_UnitTest");
+
+CWspHeaderReader_EncodingVersionNullVersion_UnitTest* CWspHeaderReader_EncodingVersionNullVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionNullVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionNullVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionNullVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionNullVersionValidator;
+ iEncodingVersionNullVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionNullVersion_UnitTest::~CWspHeaderReader_EncodingVersionNullVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionNullVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionNullVersion_UnitTest::CWspHeaderReader_EncodingVersionNullVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionNullVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionNullVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 version = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionNullVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionNullVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionTextVersionUnitTest,"CWspHeaderReader_EncodingVersionTextVersion_UnitTest");
+
+CWspHeaderReader_EncodingVersionTextVersion_UnitTest* CWspHeaderReader_EncodingVersionTextVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionTextVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionTextVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionTextVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionTextVersionValidator;
+ iEncodingVersionTextVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionTextVersion_UnitTest::~CWspHeaderReader_EncodingVersionTextVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionTextVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionTextVersion_UnitTest::CWspHeaderReader_EncodingVersionTextVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionTextVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionTextVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtVersion, "31.5\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtVersion);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "31.5");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionTextVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionTextVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionCodePageUnitTest,"CWspHeaderReader_EncodingVersionCodePage_UnitTest");
+
+CWspHeaderReader_EncodingVersionCodePage_UnitTest* CWspHeaderReader_EncodingVersionCodePage_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionCodePage_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionCodePage_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionCodePage_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionCodePageValidator;
+ iEncodingVersionCodePageValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePage_UnitTest::~CWspHeaderReader_EncodingVersionCodePage_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionCodePageValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePage_UnitTest::CWspHeaderReader_EncodingVersionCodePage_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionCodePageUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionCodePage_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 valLength = 0x01;
+ TUint8 codePage = 0x81;
+ iUTContext->iTestHeader->WriteRawDataL(valLength);
+ iUTContext->iTestHeader->WriteRawDataL(codePage);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionCodePageValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionCodePageValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionCodePageIntVersionUnitTest,"CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest");
+
+CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest* CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionCodePageIntVersionValidator;
+ iEncodingVersionCodePageIntVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest::~CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionCodePageIntVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest::CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionCodePageIntVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionCodePageIntVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 valLength = 0x02;
+ TUint8 codePage = 0x81;
+ TUint8 version = 0x91;
+ iUTContext->iTestHeader->WriteRawDataL(valLength);
+ iUTContext->iTestHeader->WriteRawDataL(codePage);
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1,1.1");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionCodePageIntVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionCodePageIntVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionCodePageTextVersionUnitTest,"CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest");
+
+CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest* CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionCodePageTextVersionValidator;
+ iEncodingVersionCodePageTextVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest::~CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionCodePageTextVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest::CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionCodePageTextVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionCodePageTextVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 valLength = 0x06;
+ TUint8 codePage = 0x81;
+ _LIT8(KTxtVersion, "31.5\0");
+ iUTContext->iTestHeader->WriteRawDataL(valLength);
+ iUTContext->iTestHeader->WriteRawDataL(codePage);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtVersion);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1,31.5");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionCodePageTextVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionCodePageTextVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderEncodingVersionCodePageNullVersionUnitTest,"CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest");
+
+CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest* CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest* self =
+ new(ELeave) CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iEncodingVersionCodePageNullVersionValidator;
+ iEncodingVersionCodePageNullVersionValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest::~CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iEncodingVersionCodePageNullVersionValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest::CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderEncodingVersionCodePageNullVersionUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_EncodingVersionCodePageNullVersion_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EEncodingVersion);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 valLength = 0x06;
+ TUint8 codePage = 0x81;
+ TUint8 version = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(valLength);
+ iUTContext->iTestHeader->WriteRawDataL(codePage);
+ iUTContext->iTestHeader->WriteRawDataL(version);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "1,");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iEncodingVersionCodePageNullVersionValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iEncodingVersionCodePageNullVersionValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAcceptRangesNoneUnitTest,"CWspHeaderReader_AcceptRangesNone_UnitTest");
+
+CWspHeaderReader_AcceptRangesNone_UnitTest* CWspHeaderReader_AcceptRangesNone_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AcceptRangesNone_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AcceptRangesNone_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AcceptRangesNone_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAcceptRangesNoneValidator;
+ iAcceptRangesNoneValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AcceptRangesNone_UnitTest::~CWspHeaderReader_AcceptRangesNone_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAcceptRangesNoneValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AcceptRangesNone_UnitTest::CWspHeaderReader_AcceptRangesNone_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAcceptRangesNoneUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AcceptRangesNone_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAcceptRanges);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 noneToken = 0x80; // token value for 'none'
+ iUTContext->iTestHeader->WriteRawDataL(noneToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "None");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAcceptRangesNoneValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iAcceptRangesNoneValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAcceptRangesBytesUnitTest,"CWspHeaderReader_AcceptRangesBytes_UnitTest");
+
+CWspHeaderReader_AcceptRangesBytes_UnitTest* CWspHeaderReader_AcceptRangesBytes_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AcceptRangesBytes_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AcceptRangesBytes_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AcceptRangesBytes_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAcceptRangesBytesValidator;
+ iAcceptRangesBytesValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AcceptRangesBytes_UnitTest::~CWspHeaderReader_AcceptRangesBytes_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAcceptRangesBytesValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AcceptRangesBytes_UnitTest::CWspHeaderReader_AcceptRangesBytes_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAcceptRangesBytesUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AcceptRangesBytes_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAcceptRanges);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 bytesToken = 0x81; // token value for 'bytes'
+ iUTContext->iTestHeader->WriteRawDataL(bytesToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Bytes");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAcceptRangesBytesValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iAcceptRangesBytesValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAcceptRangesTokenTextUnitTest,"CWspHeaderReader_AcceptRangesTokenText_UnitTest");
+
+CWspHeaderReader_AcceptRangesTokenText_UnitTest* CWspHeaderReader_AcceptRangesTokenText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AcceptRangesTokenText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AcceptRangesTokenText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AcceptRangesTokenText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAcceptRangesTokenTextValidator;
+ iAcceptRangesTokenTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AcceptRangesTokenText_UnitTest::~CWspHeaderReader_AcceptRangesTokenText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAcceptRangesTokenTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AcceptRangesTokenText_UnitTest::CWspHeaderReader_AcceptRangesTokenText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAcceptRangesTokenTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AcceptRangesTokenText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAcceptRanges);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtToken, "accept-ranges-token-text\0"); // token text
+ iUTContext->iTestHeader->WriteRawDataL(KTxtToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "accept-ranges-token-text");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAcceptRangesTokenTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iAcceptRangesTokenTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentEncodingGZipUnitTest,"CWspHeaderReader_ContentEncodingGZip_UnitTest");
+
+CWspHeaderReader_ContentEncodingGZip_UnitTest* CWspHeaderReader_ContentEncodingGZip_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentEncodingGZip_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentEncodingGZip_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentEncodingGZip_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentEncodingGZipValidator;
+ iContentEncodingGZipValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentEncodingGZip_UnitTest::~CWspHeaderReader_ContentEncodingGZip_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentEncodingGZipValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentEncodingGZip_UnitTest::CWspHeaderReader_ContentEncodingGZip_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentEncodingGZipUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentEncodingGZip_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentEncoding);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 gzipToken = 0x80;
+ iUTContext->iTestHeader->WriteRawDataL(gzipToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "GZip");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentEncodingGZipValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentEncodingGZipValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentEncodingCompressUnitTest,"CWspHeaderReader_ContentEncodingCompress_UnitTest");
+
+CWspHeaderReader_ContentEncodingCompress_UnitTest* CWspHeaderReader_ContentEncodingCompress_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentEncodingCompress_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentEncodingCompress_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentEncodingCompress_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentEncodingCompressValidator;
+ iContentEncodingCompressValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentEncodingCompress_UnitTest::~CWspHeaderReader_ContentEncodingCompress_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentEncodingCompressValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentEncodingCompress_UnitTest::CWspHeaderReader_ContentEncodingCompress_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentEncodingCompressUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentEncodingCompress_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentEncoding);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 compressToken = 0x81;
+ iUTContext->iTestHeader->WriteRawDataL(compressToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Compress");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentEncodingCompressValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentEncodingCompressValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentEncodingDeflateUnitTest,"CWspHeaderReader_ContentEncodingDeflate_UnitTest");
+
+CWspHeaderReader_ContentEncodingDeflate_UnitTest* CWspHeaderReader_ContentEncodingDeflate_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentEncodingDeflate_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentEncodingDeflate_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentEncodingDeflate_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentEncodingDeflateValidator;
+ iContentEncodingDeflateValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentEncodingDeflate_UnitTest::~CWspHeaderReader_ContentEncodingDeflate_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentEncodingDeflateValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentEncodingDeflate_UnitTest::CWspHeaderReader_ContentEncodingDeflate_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentEncodingDeflateUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentEncodingDeflate_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentEncoding);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 deflateToken = 0x82;
+ iUTContext->iTestHeader->WriteRawDataL(deflateToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Deflate");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentEncodingDeflateValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentEncodingDeflateValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentEncodingTokenTextUnitTest,"CWspHeaderReader_ContentEncodingTokenText_UnitTest");
+
+CWspHeaderReader_ContentEncodingTokenText_UnitTest* CWspHeaderReader_ContentEncodingTokenText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentEncodingTokenText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentEncodingTokenText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentEncodingTokenText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentEncodingTokenTextValidator;
+ iContentEncodingTokenTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentEncodingTokenText_UnitTest::~CWspHeaderReader_ContentEncodingTokenText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentEncodingTokenTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentEncodingTokenText_UnitTest::CWspHeaderReader_ContentEncodingTokenText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentEncodingTokenTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentEncodingTokenText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentEncoding);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtTokenText, "token-text\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTokenText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Token-text");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentEncodingTokenTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentEncodingTokenTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLanguageAnyLangUnitTest,"CWspHeaderReader_ContentLanguageAnyLang_UnitTest");
+
+CWspHeaderReader_ContentLanguageAnyLang_UnitTest* CWspHeaderReader_ContentLanguageAnyLang_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLanguageAnyLang_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLanguageAnyLang_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLanguageAnyLang_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLanguageAnyLangValidator;
+ iContentLanguageAnyLangValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLanguageAnyLang_UnitTest::~CWspHeaderReader_ContentLanguageAnyLang_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLanguageAnyLangValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLanguageAnyLang_UnitTest::CWspHeaderReader_ContentLanguageAnyLang_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLanguageAnyLangUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLanguageAnyLang_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLanguage);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 anyLang = 0x80;
+ iUTContext->iTestHeader->WriteRawDataL(anyLang);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "*");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLanguageAnyLangValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentLanguageAnyLangValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLanguageShortIntUnitTest,"CWspHeaderReader_ContentLanguageShortInt_UnitTest");
+
+CWspHeaderReader_ContentLanguageShortInt_UnitTest* CWspHeaderReader_ContentLanguageShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLanguageShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLanguageShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLanguageShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLanguageShortIntValidator;
+ iContentLanguageShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLanguageShortInt_UnitTest::~CWspHeaderReader_ContentLanguageShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLanguageShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLanguageShortInt_UnitTest::CWspHeaderReader_ContentLanguageShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLanguageShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLanguageShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLanguage);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 spanish = 0x9B; // token for spanish 'es' language with top bit set
+ iUTContext->iTestHeader->WriteRawDataL(spanish);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "es");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLanguageShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentLanguageShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLanguageLongIntUnitTest,"CWspHeaderReader_ContentLanguageLongInt_UnitTest");
+
+CWspHeaderReader_ContentLanguageLongInt_UnitTest* CWspHeaderReader_ContentLanguageLongInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLanguageLongInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLanguageLongInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLanguageLongInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLanguageLongIntValidator;
+ iContentLanguageLongIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLanguageLongInt_UnitTest::~CWspHeaderReader_ContentLanguageLongInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLanguageLongIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLanguageLongInt_UnitTest::CWspHeaderReader_ContentLanguageLongInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLanguageLongIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLanguageLongInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLanguage);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x01;
+ TUint8 greenlandic = 0x8A; // token for grrenlanic 'kl'
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(greenlandic);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "kl");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLanguageLongIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentLanguageLongIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLanguageTokenTextUnitTest,"CWspHeaderReader_ContentLanguageTokenText_UnitTest");
+
+CWspHeaderReader_ContentLanguageTokenText_UnitTest* CWspHeaderReader_ContentLanguageTokenText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLanguageTokenText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLanguageTokenText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLanguageTokenText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLanguageTokenTextValidator;
+ iContentLanguageTokenTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLanguageTokenText_UnitTest::~CWspHeaderReader_ContentLanguageTokenText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLanguageTokenTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLanguageTokenText_UnitTest::CWspHeaderReader_ContentLanguageTokenText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLanguageTokenTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLanguageTokenText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLanguage);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtTokenText, "language-in-text\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTokenText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "language-in-text");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLanguageTokenTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentLanguageTokenTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLanguageNotExistUnitTest,"CWspHeaderReader_ContentLanguageNotExist_UnitTest");
+
+CWspHeaderReader_ContentLanguageNotExist_UnitTest* CWspHeaderReader_ContentLanguageNotExist_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLanguageNotExist_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLanguageNotExist_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLanguageNotExist_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLanguageNotExistValidator;
+ iContentLanguageNotExistValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLanguageNotExist_UnitTest::~CWspHeaderReader_ContentLanguageNotExist_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLanguageNotExistValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLanguageNotExist_UnitTest::CWspHeaderReader_ContentLanguageNotExist_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLanguageNotExistUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLanguageNotExist_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLanguage);
+ TUint8 length = 0x02;
+ TUint8 notExist1 = 0x8A;
+ TUint8 notExist2 = 0x81;
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(notExist1);
+ iUTContext->iTestHeader->WriteRawDataL(notExist2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLanguageNotExistValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iContentLanguageNotExistValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentMD5UnitTest,"CWspHeaderReader_ContentMD5_UnitTest");
+
+CWspHeaderReader_ContentMD5_UnitTest* CWspHeaderReader_ContentMD5_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentMD5_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentMD5_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentMD5_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentMD5Validator;
+ iContentMD5Validator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentMD5_UnitTest::~CWspHeaderReader_ContentMD5_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentMD5Validator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentMD5_UnitTest::CWspHeaderReader_ContentMD5_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentMD5UnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentMD5_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentMD5);
+ TUint8 length = 0x10;
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtMD5Data, "ThisIsContentMD5");
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtMD5Data);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "ThisIsContentMD5");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentMD5Validator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentMD5Validator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentMD5TooShortUnitTest,"CWspHeaderReader_ContentMD5TooShort_UnitTest");
+
+CWspHeaderReader_ContentMD5TooShort_UnitTest* CWspHeaderReader_ContentMD5TooShort_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentMD5TooShort_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentMD5TooShort_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentMD5TooShort_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentMD5TooShortValidator;
+ iContentMD5TooShortValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentMD5TooShort_UnitTest::~CWspHeaderReader_ContentMD5TooShort_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentMD5TooShortValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentMD5TooShort_UnitTest::CWspHeaderReader_ContentMD5TooShort_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentMD5TooShortUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentMD5TooShort_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentMD5);
+ TUint8 length = 0x10; // length of 16, but actual data is less
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtMD5Data, "ThisIsTooShort");
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtMD5Data);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentMD5TooShortValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iContentMD5TooShortValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProxyAuthenticateBasicUnitTest,"CWspHeaderReader_ProxyAuthenticateBasic_UnitTest");
+
+CWspHeaderReader_ProxyAuthenticateBasic_UnitTest* CWspHeaderReader_ProxyAuthenticateBasic_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProxyAuthenticateBasic_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProxyAuthenticateBasic_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProxyAuthenticateBasic_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProxyAuthenticateBasicValidator;
+ iProxyAuthenticateBasicValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProxyAuthenticateBasic_UnitTest::~CWspHeaderReader_ProxyAuthenticateBasic_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProxyAuthenticateBasicValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProxyAuthenticateBasic_UnitTest::CWspHeaderReader_ProxyAuthenticateBasic_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProxyAuthenticateBasicUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProxyAuthenticateBasic_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProxyAuthenticate);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet0D = 0x0D; // short length octet for 13 bytes
+ TUint8 octet80 = 0x80; // <octet 128> token for basic
+ _LIT8(KTxtRealm, "Realm-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(octet0D);
+ iUTContext->iTestHeader->WriteRawDataL(octet80);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtRealm());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Basic,Realm-value");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProxyAuthenticateBasicValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProxyAuthenticateBasicValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderServerTextUnitTest,"CWspHeaderReader_ServerText_UnitTest");
+
+CWspHeaderReader_ServerText_UnitTest* CWspHeaderReader_ServerText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ServerText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ServerText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ServerText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iServerTextValidator;
+ iServerTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ServerText_UnitTest::~CWspHeaderReader_ServerText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iServerTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ServerText_UnitTest::CWspHeaderReader_ServerText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderServerTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ServerText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EServer);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtText, "www.myservervalue.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "www.myservervalue.com");
+ iUTContext->SetExpectedL(KTxtExpected());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iServerTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iServerTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderServerNullTextUnitTest,"CWspHeaderReader_ServerNullText_UnitTest");
+
+CWspHeaderReader_ServerNullText_UnitTest* CWspHeaderReader_ServerNullText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ServerNullText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ServerNullText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ServerNullText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iServerNullTextValidator;
+ iServerNullTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ServerNullText_UnitTest::~CWspHeaderReader_ServerNullText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iServerNullTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ServerNullText_UnitTest::CWspHeaderReader_ServerNullText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderServerNullTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ServerNullText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EServer);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 nullString = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(nullString);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iServerNullTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iServerNullTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderRetryAfterAbsoluteDateUnitTest,"CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest");
+
+CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest* CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest* self =
+ new(ELeave) CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iRetryAfterAbsoluteDateValidator;
+ iRetryAfterAbsoluteDateValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest::~CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iRetryAfterAbsoluteDateValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest::CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderRetryAfterAbsoluteDateUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_RetryAfterAbsoluteDate_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ERetryAfter);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 valueLength = 0x05; // short int value length
+ TUint8 absoluteToken = 0x80; // token for absolute value
+ TUint8 length = 0x03; // short int length for date
+ TUint8 octet255 = 0xFF; // example date value
+ TUint8 octet254 = 0xFE; // example date value
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(absoluteToken);
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Tue, 14 Jul 1970 04:20:14 GMT");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iRetryAfterAbsoluteDateValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iRetryAfterAbsoluteDateValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderRetryAfterRelativeTimeUnitTest,"CWspHeaderReader_RetryAfterRelativeTime_UnitTest");
+
+CWspHeaderReader_RetryAfterRelativeTime_UnitTest* CWspHeaderReader_RetryAfterRelativeTime_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_RetryAfterRelativeTime_UnitTest* self =
+ new(ELeave) CWspHeaderReader_RetryAfterRelativeTime_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_RetryAfterRelativeTime_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iRetryAfterRelativeTimeValidator;
+ iRetryAfterRelativeTimeValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_RetryAfterRelativeTime_UnitTest::~CWspHeaderReader_RetryAfterRelativeTime_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iRetryAfterRelativeTimeValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_RetryAfterRelativeTime_UnitTest::CWspHeaderReader_RetryAfterRelativeTime_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderRetryAfterRelativeTimeUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_RetryAfterRelativeTime_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ERetryAfter);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 valueLength = 0x05; // short int value length
+ TUint8 relativeToken = 0x81; // token for relative value
+ TUint8 length = 0x03; // short int length for date
+ TUint8 octet255 = 0xFF; // example date value
+ TUint8 octet254 = 0xFE; // example date value
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(relativeToken);
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "16777214");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iRetryAfterRelativeTimeValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iRetryAfterRelativeTimeValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderViaTextUnitTest,"CWspHeaderReader_ViaText_UnitTest");
+
+CWspHeaderReader_ViaText_UnitTest* CWspHeaderReader_ViaText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ViaText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ViaText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ViaText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iViaTextValidator;
+ iViaTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ViaText_UnitTest::~CWspHeaderReader_ViaText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iViaTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ViaText_UnitTest::CWspHeaderReader_ViaText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderViaTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ViaText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EVia);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtString, "Via-text\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtString);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Via-text");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iViaTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iViaTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderViaNullTextUnitTest,"CWspHeaderReader_ViaNullText_UnitTest");
+
+CWspHeaderReader_ViaNullText_UnitTest* CWspHeaderReader_ViaNullText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ViaNullText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ViaNullText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ViaNullText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iViaNullTextValidator;
+ iViaNullTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ViaNullText_UnitTest::~CWspHeaderReader_ViaNullText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iViaNullTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ViaNullText_UnitTest::CWspHeaderReader_ViaNullText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderViaNullTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ViaNullText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EVia);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 nullTerminate = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(nullTerminate);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iViaNullTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iViaNullTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderViaTextWithoutTerminatorUnitTest,"CWspHeaderReader_ViaTextWithoutTerminator_UnitTest");
+
+CWspHeaderReader_ViaTextWithoutTerminator_UnitTest* CWspHeaderReader_ViaTextWithoutTerminator_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ViaTextWithoutTerminator_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ViaTextWithoutTerminator_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ViaTextWithoutTerminator_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iViaTextWithoutTerminatorValidator;
+ iViaTextWithoutTerminatorValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ViaTextWithoutTerminator_UnitTest::~CWspHeaderReader_ViaTextWithoutTerminator_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iViaTextWithoutTerminatorValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ViaTextWithoutTerminator_UnitTest::CWspHeaderReader_ViaTextWithoutTerminator_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderViaTextWithoutTerminatorUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ViaTextWithoutTerminator_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EVia);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtStringNoNull, "Via-text");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtStringNoNull);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iViaTextWithoutTerminatorValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iViaTextWithoutTerminatorValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderTrailerShortIntUnitTest,"CWspHeaderReader_TrailerShortInt_UnitTest");
+
+CWspHeaderReader_TrailerShortInt_UnitTest* CWspHeaderReader_TrailerShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_TrailerShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_TrailerShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_TrailerShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iTrailerShortIntValidator;
+ iTrailerShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_TrailerShortInt_UnitTest::~CWspHeaderReader_TrailerShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iTrailerShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_TrailerShortInt_UnitTest::CWspHeaderReader_TrailerShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderTrailerShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_TrailerShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ETrailer);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 headerToken = 0xA7; // with top bit set
+ iUTContext->iTestHeader->WriteRawDataL(headerToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Transfer-Encoding");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iTrailerShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iTrailerShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderTrailerNotExistTokenUnitTest,"CWspHeaderReader_TrailerNotExistToken_UnitTest");
+
+CWspHeaderReader_TrailerNotExistToken_UnitTest* CWspHeaderReader_TrailerNotExistToken_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_TrailerNotExistToken_UnitTest* self =
+ new(ELeave) CWspHeaderReader_TrailerNotExistToken_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_TrailerNotExistToken_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iTrailerNotExistTokenValidator;
+ iTrailerNotExistTokenValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_TrailerNotExistToken_UnitTest::~CWspHeaderReader_TrailerNotExistToken_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iTrailerNotExistTokenValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_TrailerNotExistToken_UnitTest::CWspHeaderReader_TrailerNotExistToken_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderTrailerNotExistTokenUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_TrailerNotExistToken_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ETrailer);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 headerToken = 0x50;
+ iUTContext->iTestHeader->WriteRawDataL(headerToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iTrailerNotExistTokenValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iTrailerNotExistTokenValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderTrailerTokenTextUnitTest,"CWspHeaderReader_TrailerTokenText_UnitTest");
+
+CWspHeaderReader_TrailerTokenText_UnitTest* CWspHeaderReader_TrailerTokenText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_TrailerTokenText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_TrailerTokenText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_TrailerTokenText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iTrailerTokenTextValidator;
+ iTrailerTokenTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_TrailerTokenText_UnitTest::~CWspHeaderReader_TrailerTokenText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iTrailerTokenTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_TrailerTokenText_UnitTest::CWspHeaderReader_TrailerTokenText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderTrailerTokenTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_TrailerTokenText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ETrailer);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtTokenText, "text-header-name\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTokenText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "text-header-name");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iTrailerTokenTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iTrailerTokenTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentRangeUnknownLengthUnitTest,"CWspHeaderReader_ContentRangeUnknownLength_UnitTest");
+
+CWspHeaderReader_ContentRangeUnknownLength_UnitTest* CWspHeaderReader_ContentRangeUnknownLength_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentRangeUnknownLength_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentRangeUnknownLength_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentRangeUnknownLength_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentRangeUnknownLengthValidator;
+ iContentRangeUnknownLengthValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentRangeUnknownLength_UnitTest::~CWspHeaderReader_ContentRangeUnknownLength_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentRangeUnknownLengthValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentRangeUnknownLength_UnitTest::CWspHeaderReader_ContentRangeUnknownLength_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentRangeUnknownLengthUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentRangeUnknownLength_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentRange);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x03; // length
+ TUint8 firstBytePos1 = 0x82; // UIntVar pt1
+ TUint8 firstBytePos2 = 0x05; // UIntVar pt2
+ TUint8 unknownToken = 0x80; // Token for '*'
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(firstBytePos1);
+ iUTContext->iTestHeader->WriteRawDataL(firstBytePos2);
+ iUTContext->iTestHeader->WriteRawDataL(unknownToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "261,*");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentRangeUnknownLengthValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentRangeUnknownLengthValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentRangeKnownLengthUnitTest,"CWspHeaderReader_ContentRangeKnownLength_UnitTest");
+
+CWspHeaderReader_ContentRangeKnownLength_UnitTest* CWspHeaderReader_ContentRangeKnownLength_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentRangeKnownLength_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentRangeKnownLength_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentRangeKnownLength_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentRangeKnownLengthValidator;
+ iContentRangeKnownLengthValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentRangeKnownLength_UnitTest::~CWspHeaderReader_ContentRangeKnownLength_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentRangeKnownLengthValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentRangeKnownLength_UnitTest::CWspHeaderReader_ContentRangeKnownLength_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentRangeKnownLengthUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentRangeKnownLength_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentRange);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x05; // length
+ TUint8 firstBytePos1 = 0x82; // UIntVar1 pt1
+ TUint8 firstBytePos2 = 0x05; // UIntVar1 pt2
+ TUint8 entityLen1 = 0x83; // UIntVar2 pt1
+ TUint8 entityLen2 = 0xA5; // UIntVar2 pt2
+ TUint8 entityLen3 = 0x01; // UIntVar2 pt3
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(firstBytePos1);
+ iUTContext->iTestHeader->WriteRawDataL(firstBytePos2);
+ iUTContext->iTestHeader->WriteRawDataL(entityLen1);
+ iUTContext->iTestHeader->WriteRawDataL(entityLen2);
+ iUTContext->iTestHeader->WriteRawDataL(entityLen3);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "261,53889");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentRangeKnownLengthValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentRangeKnownLengthValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentRangeV1_2UnitTest,"CWspHeaderReader_ContentRangeV1_2_UnitTest");
+
+CWspHeaderReader_ContentRangeV1_2_UnitTest* CWspHeaderReader_ContentRangeV1_2_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentRangeV1_2_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentRangeV1_2_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentRangeV1_2_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentRangeV1_2Validator;
+ iContentRangeV1_2Validator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentRangeV1_2_UnitTest::~CWspHeaderReader_ContentRangeV1_2_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentRangeV1_2Validator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentRangeV1_2_UnitTest::CWspHeaderReader_ContentRangeV1_2_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentRangeV1_2UnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentRangeV1_2_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentRange);
+ (REINTERPRET_CAST(CWspHeaderCodec*, iUTContext->iCodec))->SetWspVersion(CWspHeaderCodec::EVersion1_2);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x05; // length
+ TUint8 firstBytePos1 = 0x82; // UIntVar1 pt1
+ TUint8 firstBytePos2 = 0x05; // UIntVar1 pt2
+ TUint8 entityLen1 = 0x83; // UIntVar2 pt1
+ TUint8 entityLen2 = 0xA5; // UIntVar2 pt2
+ TUint8 entityLen3 = 0x01; // UIntVar2 pt3
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(firstBytePos1);
+ iUTContext->iTestHeader->WriteRawDataL(firstBytePos2);
+ iUTContext->iTestHeader->WriteRawDataL(entityLen1);
+ iUTContext->iTestHeader->WriteRawDataL(entityLen2);
+ iUTContext->iTestHeader->WriteRawDataL(entityLen3);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "261,53889");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentRangeV1_2Validator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentRangeV1_2Validator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderXWapAppIdUriValueUnitTest,"CWspHeaderReader_XWapAppIdUriValue_UnitTest");
+
+CWspHeaderReader_XWapAppIdUriValue_UnitTest* CWspHeaderReader_XWapAppIdUriValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_XWapAppIdUriValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_XWapAppIdUriValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_XWapAppIdUriValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iXWapAppIdUriValueValidator;
+ iXWapAppIdUriValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_XWapAppIdUriValue_UnitTest::~CWspHeaderReader_XWapAppIdUriValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iXWapAppIdUriValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_XWapAppIdUriValue_UnitTest::CWspHeaderReader_XWapAppIdUriValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderXWapAppIdUriValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_XWapAppIdUriValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EXWapApplicationId);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtUri, "http://www.symbian.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtUri);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "http://www.symbian.com");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iXWapAppIdUriValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iXWapAppIdUriValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderXWapAppIdNullUriUnitTest,"CWspHeaderReader_XWapAppIdNullUri_UnitTest");
+
+CWspHeaderReader_XWapAppIdNullUri_UnitTest* CWspHeaderReader_XWapAppIdNullUri_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_XWapAppIdNullUri_UnitTest* self =
+ new(ELeave) CWspHeaderReader_XWapAppIdNullUri_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_XWapAppIdNullUri_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iXWapAppIdNullUriValidator;
+ iXWapAppIdNullUriValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_XWapAppIdNullUri_UnitTest::~CWspHeaderReader_XWapAppIdNullUri_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iXWapAppIdNullUriValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_XWapAppIdNullUri_UnitTest::CWspHeaderReader_XWapAppIdNullUri_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderXWapAppIdNullUriUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_XWapAppIdNullUri_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EXWapApplicationId);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 nullTerminate = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(nullTerminate);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iXWapAppIdNullUriValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iXWapAppIdNullUriValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderXWapAppIdShortIntUnitTest,"CWspHeaderReader_XWapAppIdShortInt_UnitTest");
+
+CWspHeaderReader_XWapAppIdShortInt_UnitTest* CWspHeaderReader_XWapAppIdShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_XWapAppIdShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_XWapAppIdShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_XWapAppIdShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iXWapAppIdShortIntValidator;
+ iXWapAppIdShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_XWapAppIdShortInt_UnitTest::~CWspHeaderReader_XWapAppIdShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iXWapAppIdShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_XWapAppIdShortInt_UnitTest::CWspHeaderReader_XWapAppIdShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderXWapAppIdShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_XWapAppIdShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EXWapApplicationId);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 shortInt = 0x87; // Short int with top bit set
+ iUTContext->iTestHeader->WriteRawDataL(shortInt);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "7");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iXWapAppIdShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iXWapAppIdShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderXWapAppIdLongIntUnitTest,"CWspHeaderReader_XWapAppIdLongInt_UnitTest");
+
+CWspHeaderReader_XWapAppIdLongInt_UnitTest* CWspHeaderReader_XWapAppIdLongInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_XWapAppIdLongInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_XWapAppIdLongInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_XWapAppIdLongInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iXWapAppIdLongIntValidator;
+ iXWapAppIdLongIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_XWapAppIdLongInt_UnitTest::~CWspHeaderReader_XWapAppIdLongInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iXWapAppIdLongIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_XWapAppIdLongInt_UnitTest::CWspHeaderReader_XWapAppIdLongInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderXWapAppIdLongIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_XWapAppIdLongInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EXWapApplicationId);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 shortlength = 0x02; // length
+ TUint8 longInt1 = 0x4A;
+ TUint8 longInt2 = 0x80;
+ iUTContext->iTestHeader->WriteRawDataL(shortlength);
+ iUTContext->iTestHeader->WriteRawDataL(longInt1);
+ iUTContext->iTestHeader->WriteRawDataL(longInt2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "19072");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iXWapAppIdLongIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iXWapAppIdLongIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderXWapInitUriTextValueUnitTest,"CWspHeaderReader_XWapInitUriTextValue_UnitTest");
+
+CWspHeaderReader_XWapInitUriTextValue_UnitTest* CWspHeaderReader_XWapInitUriTextValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_XWapInitUriTextValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_XWapInitUriTextValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_XWapInitUriTextValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iXWapInitUriTextValueValidator;
+ iXWapInitUriTextValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_XWapInitUriTextValue_UnitTest::~CWspHeaderReader_XWapInitUriTextValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iXWapInitUriTextValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_XWapInitUriTextValue_UnitTest::CWspHeaderReader_XWapInitUriTextValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderXWapInitUriTextValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_XWapInitUriTextValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EXWapInitiatorURI);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtUri, "http://www.symbian.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtUri);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "http://www.symbian.com");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iXWapInitUriTextValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iXWapInitUriTextValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderXWapInitUriNullValueUnitTest,"CWspHeaderReader_XWapInitUriNullValue_UnitTest");
+
+CWspHeaderReader_XWapInitUriNullValue_UnitTest* CWspHeaderReader_XWapInitUriNullValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_XWapInitUriNullValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_XWapInitUriNullValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_XWapInitUriNullValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iXWapInitUriNullValueValidator;
+ iXWapInitUriNullValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_XWapInitUriNullValue_UnitTest::~CWspHeaderReader_XWapInitUriNullValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iXWapInitUriNullValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_XWapInitUriNullValue_UnitTest::CWspHeaderReader_XWapInitUriNullValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderXWapInitUriNullValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_XWapInitUriNullValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EXWapInitiatorURI);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 nullTerminate = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(nullTerminate);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iXWapInitUriNullValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iXWapInitUriNullValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderPushFlagShortIntUnitTest,"CWspHeaderReader_PushFlagShortInt_UnitTest");
+
+CWspHeaderReader_PushFlagShortInt_UnitTest* CWspHeaderReader_PushFlagShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_PushFlagShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_PushFlagShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_PushFlagShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iPushFlagShortIntValidator;
+ iPushFlagShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_PushFlagShortInt_UnitTest::~CWspHeaderReader_PushFlagShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iPushFlagShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_PushFlagShortInt_UnitTest::CWspHeaderReader_PushFlagShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderPushFlagShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_PushFlagShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EPushFlag);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 shortInt = 0xA9; // short int with top bit set
+ iUTContext->iTestHeader->WriteRawDataL(shortInt);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "41");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iPushFlagShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iPushFlagShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderPushFlagLongIntUnitTest,"CWspHeaderReader_PushFlagLongInt_UnitTest");
+
+CWspHeaderReader_PushFlagLongInt_UnitTest* CWspHeaderReader_PushFlagLongInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_PushFlagLongInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_PushFlagLongInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_PushFlagLongInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iPushFlagLongIntValidator;
+ iPushFlagLongIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_PushFlagLongInt_UnitTest::~CWspHeaderReader_PushFlagLongInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iPushFlagLongIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_PushFlagLongInt_UnitTest::CWspHeaderReader_PushFlagLongInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderPushFlagLongIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_PushFlagLongInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EPushFlag);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x02;
+ TUint8 longInt1 = 0xA8;
+ TUint8 longInt2 = 0x05;
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(longInt1);
+ iUTContext->iTestHeader->WriteRawDataL(longInt2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iPushFlagLongIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iPushFlagLongIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderPushFlagTextValueUnitTest,"CWspHeaderReader_PushFlagTextValue_UnitTest");
+
+CWspHeaderReader_PushFlagTextValue_UnitTest* CWspHeaderReader_PushFlagTextValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_PushFlagTextValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_PushFlagTextValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_PushFlagTextValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iPushFlagTextValueValidator;
+ iPushFlagTextValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_PushFlagTextValue_UnitTest::~CWspHeaderReader_PushFlagTextValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iPushFlagTextValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_PushFlagTextValue_UnitTest::CWspHeaderReader_PushFlagTextValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderPushFlagTextValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_PushFlagTextValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EPushFlag);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtValue, "test-text-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtValue);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iPushFlagTextValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iPushFlagTextValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAllowGetUnitTest,"CWspHeaderReader_AllowGet_UnitTest");
+
+CWspHeaderReader_AllowGet_UnitTest* CWspHeaderReader_AllowGet_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AllowGet_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AllowGet_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AllowGet_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAllowGetValidator;
+ iAllowGetValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AllowGet_UnitTest::~CWspHeaderReader_AllowGet_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAllowGetValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AllowGet_UnitTest::CWspHeaderReader_AllowGet_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAllowGetUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AllowGet_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAllow);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 getToken = 0xC0; // short int Get token with top bit set
+ iUTContext->iTestHeader->WriteRawDataL(getToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Get");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAllowGetValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iAllowGetValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAllowTraceUnitTest,"CWspHeaderReader_AllowTrace_UnitTest");
+
+CWspHeaderReader_AllowTrace_UnitTest* CWspHeaderReader_AllowTrace_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AllowTrace_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AllowTrace_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AllowTrace_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAllowTraceValidator;
+ iAllowTraceValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AllowTrace_UnitTest::~CWspHeaderReader_AllowTrace_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAllowTraceValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AllowTrace_UnitTest::CWspHeaderReader_AllowTrace_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAllowTraceUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AllowTrace_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAllow);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 traceToken = 0xC4; // short int Trace token with top bit set
+ iUTContext->iTestHeader->WriteRawDataL(traceToken);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "Trace");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAllowTraceValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iAllowTraceValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAllowLongIntUnitTest,"CWspHeaderReader_AllowLongInt_UnitTest");
+
+CWspHeaderReader_AllowLongInt_UnitTest* CWspHeaderReader_AllowLongInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AllowLongInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AllowLongInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AllowLongInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAllowLongIntValidator;
+ iAllowLongIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AllowLongInt_UnitTest::~CWspHeaderReader_AllowLongInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAllowLongIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AllowLongInt_UnitTest::CWspHeaderReader_AllowLongInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAllowLongIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AllowLongInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAllow);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x02; // long int length
+ TUint8 longInt1 = 0x45;
+ TUint8 longInt2 = 0xA1;
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(longInt1);
+ iUTContext->iTestHeader->WriteRawDataL(longInt2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-20");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAllowLongIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iAllowLongIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAllowInvalidShortIntUnitTest,"CWspHeaderReader_AllowInvalidShortInt_UnitTest");
+
+CWspHeaderReader_AllowInvalidShortInt_UnitTest* CWspHeaderReader_AllowInvalidShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AllowInvalidShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AllowInvalidShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AllowInvalidShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAllowInvalidShortIntValidator;
+ // iAllowInvalidShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AllowInvalidShortInt_UnitTest::~CWspHeaderReader_AllowInvalidShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAllowInvalidShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AllowInvalidShortInt_UnitTest::CWspHeaderReader_AllowInvalidShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAllowInvalidShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AllowInvalidShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAllow);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 shortInt = 0xF0; // invalid short int token
+ iUTContext->iTestHeader->WriteRawDataL(shortInt);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "-5");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAllowInvalidShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderLTrap_Transition(*iUTContext,*iAllowInvalidShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderUpgradeTextUnitTest,"CWspHeaderReader_UpgradeText_UnitTest");
+
+CWspHeaderReader_UpgradeText_UnitTest* CWspHeaderReader_UpgradeText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_UpgradeText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_UpgradeText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_UpgradeText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iUpgradeTextValidator;
+ iUpgradeTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_UpgradeText_UnitTest::~CWspHeaderReader_UpgradeText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iUpgradeTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_UpgradeText_UnitTest::CWspHeaderReader_UpgradeText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderUpgradeTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_UpgradeText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EUpgrade);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtUpgrade, "HTTP/1.2\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtUpgrade);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "HTTP/1.2");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iUpgradeTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iUpgradeTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderUpgradeNullTextUnitTest,"CWspHeaderReader_UpgradeNullText_UnitTest");
+
+CWspHeaderReader_UpgradeNullText_UnitTest* CWspHeaderReader_UpgradeNullText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_UpgradeNullText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_UpgradeNullText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_UpgradeNullText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iUpgradeNullTextValidator;
+ iUpgradeNullTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_UpgradeNullText_UnitTest::~CWspHeaderReader_UpgradeNullText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iUpgradeNullTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_UpgradeNullText_UnitTest::CWspHeaderReader_UpgradeNullText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderUpgradeNullTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_UpgradeNullText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EUpgrade);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 nullTerminate = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(nullTerminate);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iUpgradeNullTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iUpgradeNullTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWarningShortIntUnitTest,"CWspHeaderReader_WarningShortInt_UnitTest");
+
+CWspHeaderReader_WarningShortInt_UnitTest* CWspHeaderReader_WarningShortInt_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WarningShortInt_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WarningShortInt_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WarningShortInt_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWarningShortIntValidator;
+ iWarningShortIntValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WarningShortInt_UnitTest::~CWspHeaderReader_WarningShortInt_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWarningShortIntValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WarningShortInt_UnitTest::CWspHeaderReader_WarningShortInt_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWarningShortIntUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WarningShortInt_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWarning);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 warning = 0x8D; // Short int token for 13 (113)
+ iUTContext->iTestHeader->WriteRawDataL(warning);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "113");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWarningShortIntValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWarningShortIntValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWarningFullValueUnitTest,"CWspHeaderReader_WarningFullValue_UnitTest");
+
+CWspHeaderReader_WarningFullValue_UnitTest* CWspHeaderReader_WarningFullValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WarningFullValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WarningFullValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WarningFullValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWarningFullValueValidator;
+ iWarningFullValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WarningFullValue_UnitTest::~CWspHeaderReader_WarningFullValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWarningFullValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WarningFullValue_UnitTest::CWspHeaderReader_WarningFullValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWarningFullValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WarningFullValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWarning);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x1D; // length for 29 bytes
+ TUint8 warning = 0x8A; // Short int token for 10 (110)
+ _LIT8(KTxtWarnAgent, "my-warn-agent\0");
+ _LIT8(KTxtWarnText, "my-warn-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(warning);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnAgent);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "110,my-warn-agent,my-warn-value");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWarningFullValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWarningFullValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWarningShortWarnNullAgentUnitTest,"CWspHeaderReader_WarningShortWarnNullAgent_UnitTest");
+
+CWspHeaderReader_WarningShortWarnNullAgent_UnitTest* CWspHeaderReader_WarningShortWarnNullAgent_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WarningShortWarnNullAgent_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WarningShortWarnNullAgent_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WarningShortWarnNullAgent_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWarningShortWarnNullAgentValidator;
+ iWarningShortWarnNullAgentValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WarningShortWarnNullAgent_UnitTest::~CWspHeaderReader_WarningShortWarnNullAgent_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWarningShortWarnNullAgentValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WarningShortWarnNullAgent_UnitTest::CWspHeaderReader_WarningShortWarnNullAgent_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWarningShortWarnNullAgentUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WarningShortWarnNullAgent_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWarning);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x10; // length for 16 bytes
+ TUint8 warning = 0xA5; // Short int token for 10 (110)
+ TUint8 KTxtWarnAgent = 0x00;
+ _LIT8(KTxtWarnText, "my-warn-value\0");
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(warning);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnAgent);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "37,,my-warn-value");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWarningShortWarnNullAgentValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWarningShortWarnNullAgentValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWarningShortIntNullTextUnitTest,"CWspHeaderReader_WarningShortIntNullText_UnitTest");
+
+CWspHeaderReader_WarningShortIntNullText_UnitTest* CWspHeaderReader_WarningShortIntNullText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WarningShortIntNullText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WarningShortIntNullText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WarningShortIntNullText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWarningShortIntNullTextValidator;
+ iWarningShortIntNullTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WarningShortIntNullText_UnitTest::~CWspHeaderReader_WarningShortIntNullText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWarningShortIntNullTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WarningShortIntNullText_UnitTest::CWspHeaderReader_WarningShortIntNullText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWarningShortIntNullTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WarningShortIntNullText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWarning);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x10; // length for 16 bytes
+ TUint8 warning = 0xE3; // Short int token for 99 (199)
+ _LIT8(KTxtWarnAgent, "my-warn-agent\0");
+ TUint8 KTxtWarnText = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(warning);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnAgent);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "199,my-warn-agent,");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWarningShortIntNullTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWarningShortIntNullTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderWarningShortIntNullAgentNullTextUnitTest,"CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest");
+
+CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest* CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest* self =
+ new(ELeave) CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iWarningShortIntNullAgentNullTextValidator;
+ iWarningShortIntNullAgentNullTextValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest::~CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iWarningShortIntNullAgentNullTextValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest::CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderWarningShortIntNullAgentNullTextUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_WarningShortIntNullAgentNullText_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EWarning);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 length = 0x03; // length for 3 bytes
+ TUint8 warning = 0x8E; // Short int token for 14 (214)
+ TUint8 KTxtWarnAgent = 0x00;
+ TUint8 KTxtWarnText = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(length);
+ iUTContext->iTestHeader->WriteRawDataL(warning);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnAgent);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnText);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "214,,");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iWarningShortIntNullAgentNullTextValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iWarningShortIntNullAgentNullTextValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentEncodingMultiHeaderUnitTest,"CWspHeaderReader_ContentEncodingMultiHeader_UnitTest");
+
+CWspHeaderReader_ContentEncodingMultiHeader_UnitTest* CWspHeaderReader_ContentEncodingMultiHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentEncodingMultiHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentEncodingMultiHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentEncodingMultiHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentEncodingMultiHeaderValidator;
+ iContentEncodingMultiHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentEncodingMultiHeader_UnitTest::~CWspHeaderReader_ContentEncodingMultiHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentEncodingMultiHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentEncodingMultiHeader_UnitTest::CWspHeaderReader_ContentEncodingMultiHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentEncodingMultiHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentEncodingMultiHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentEncoding);
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(0x80); // token for Gzip
+ iUTContext->iTestHeader->WriteRawDataL(0x8B); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0x81); // token for Compress
+ iUTContext->iTestHeader->WriteRawDataL(0x8B); // separator
+ _LIT8(KTxtToken, "my-encoding\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtToken);
+ iUTContext->iTestHeader->CommitRawData();
+
+ _LIT8(KTxtExpected, "GZip,Compress,my-encoding");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentEncodingMultiHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentEncodingMultiHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderContentLanguageMultiHeaderUnitTest,"CWspHeaderReader_ContentLanguageMultiHeader_UnitTest");
+
+CWspHeaderReader_ContentLanguageMultiHeader_UnitTest* CWspHeaderReader_ContentLanguageMultiHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ContentLanguageMultiHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ContentLanguageMultiHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ContentLanguageMultiHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iContentLanguageMultiHeaderValidator;
+ iContentLanguageMultiHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ContentLanguageMultiHeader_UnitTest::~CWspHeaderReader_ContentLanguageMultiHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iContentLanguageMultiHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ContentLanguageMultiHeader_UnitTest::CWspHeaderReader_ContentLanguageMultiHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderContentLanguageMultiHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ContentLanguageMultiHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EContentLanguage);
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(0x80); // token '*' any
+ iUTContext->iTestHeader->WriteRawDataL(0x8C); // separator
+ _LIT8(KTxtToken, "my-language\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtToken);
+ iUTContext->iTestHeader->WriteRawDataL(0x8C); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0x99); // token 'en'
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "*,my-language,en");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iContentLanguageMultiHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iContentLanguageMultiHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderViaMultiHeaderUnitTest,"CWspHeaderReader_ViaMultiHeader_UnitTest");
+
+CWspHeaderReader_ViaMultiHeader_UnitTest* CWspHeaderReader_ViaMultiHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ViaMultiHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ViaMultiHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ViaMultiHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iViaMultiHeaderValidator;
+ iViaMultiHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ViaMultiHeader_UnitTest::~CWspHeaderReader_ViaMultiHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iViaMultiHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ViaMultiHeader_UnitTest::CWspHeaderReader_ViaMultiHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderViaMultiHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ViaMultiHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EVia);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtVia1, "symbian.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtVia1);
+ iUTContext->iTestHeader->WriteRawDataL(0xAB); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0x00);
+ iUTContext->iTestHeader->WriteRawDataL(0xAB); // separator
+ _LIT8(KTxtVia2, "1.1 devnet.org.uk\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtVia2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "symbian.com,,1.1 devnet.org.uk");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iViaMultiHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iViaMultiHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderTrailerMultiHeaderUnitTest,"CWspHeaderReader_TrailerMultiHeader_UnitTest");
+
+CWspHeaderReader_TrailerMultiHeader_UnitTest* CWspHeaderReader_TrailerMultiHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_TrailerMultiHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_TrailerMultiHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_TrailerMultiHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iTrailerMultiHeaderValidator;
+ iTrailerMultiHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_TrailerMultiHeader_UnitTest::~CWspHeaderReader_TrailerMultiHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iTrailerMultiHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_TrailerMultiHeader_UnitTest::CWspHeaderReader_TrailerMultiHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderTrailerMultiHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_TrailerMultiHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::ETrailer);
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(0x95); // 'From' token
+ iUTContext->iTestHeader->WriteRawDataL(0xBA); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0xC3); // 'Encoding-version' token
+ iUTContext->iTestHeader->WriteRawDataL(0xBA); // separator
+ _LIT8(KTxtTrailer, "my-header\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTrailer);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "From,Encoding-version,my-header");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iTrailerMultiHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iTrailerMultiHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderUpgradeMultiHeaderUnitTest,"CWspHeaderReader_UpgradeMultiHeader_UnitTest");
+
+CWspHeaderReader_UpgradeMultiHeader_UnitTest* CWspHeaderReader_UpgradeMultiHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_UpgradeMultiHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_UpgradeMultiHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_UpgradeMultiHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iUpgradeMultiHeaderValidator;
+ iUpgradeMultiHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_UpgradeMultiHeader_UnitTest::~CWspHeaderReader_UpgradeMultiHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iUpgradeMultiHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_UpgradeMultiHeader_UnitTest::CWspHeaderReader_UpgradeMultiHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderUpgradeMultiHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_UpgradeMultiHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EUpgrade);
+ iUTContext->iTestHeader->BeginRawDataL();
+ _LIT8(KTxtUpgrade1, "symbian.com\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtUpgrade1);
+ iUTContext->iTestHeader->WriteRawDataL(0xA8); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0x00);
+ iUTContext->iTestHeader->WriteRawDataL(0xA8); // separator
+ _LIT8(KTxtUpgrade2, "devnet.org.uk\0");
+ iUTContext->iTestHeader->WriteRawDataL(KTxtUpgrade2);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "symbian.com,,devnet.org.uk");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iUpgradeMultiHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iUpgradeMultiHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderAllowMultiHeaderUnitTest,"CWspHeaderReader_AllowMultiHeader_UnitTest");
+
+CWspHeaderReader_AllowMultiHeader_UnitTest* CWspHeaderReader_AllowMultiHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_AllowMultiHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_AllowMultiHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_AllowMultiHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iAllowMultiHeaderValidator;
+ iAllowMultiHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_AllowMultiHeader_UnitTest::~CWspHeaderReader_AllowMultiHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iAllowMultiHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_AllowMultiHeader_UnitTest::CWspHeaderReader_AllowMultiHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderAllowMultiHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_AllowMultiHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EAllow);
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(0xC0);
+ iUTContext->iTestHeader->WriteRawDataL(0x86); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0xE0);
+ iUTContext->iTestHeader->WriteRawDataL(0x86); // separator
+ iUTContext->iTestHeader->WriteRawDataL(0xC4);
+ iUTContext->iTestHeader->CommitRawData();
+
+ _LIT8(KTxtExpected, "Get,Post,Trace");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iAllowMultiHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iAllowMultiHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderUnknownHeaderUnitTest,"CWspHeaderReader_UnknownHeader_UnitTest");
+
+CWspHeaderReader_UnknownHeader_UnitTest* CWspHeaderReader_UnknownHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_UnknownHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_UnknownHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_UnknownHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iUnknownHeaderValidator;
+ iUnknownHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_UnknownHeader_UnitTest::~CWspHeaderReader_UnknownHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iUnknownHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_UnknownHeader_UnitTest::CWspHeaderReader_UnknownHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderUnknownHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_UnknownHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ // Passing KErrNotFound will create a header field called TestHeader which is not recognised by the
+ // WSP header codec and the default WSP header codec will be used instead
+ iUTContext->ConstructL(KErrNotFound);
+ _LIT8(KTxtSampleData, "This is some sample header field data\0");
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(KTxtSampleData());
+ iUTContext->iTestHeader->CommitRawData();
+
+ _LIT8(KTxtExpected, "This is some sample header field data");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iUnknownHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iUnknownHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderUnknownHeaderNullUnitTest,"CWspHeaderReader_UnknownHeaderNull_UnitTest");
+
+CWspHeaderReader_UnknownHeaderNull_UnitTest* CWspHeaderReader_UnknownHeaderNull_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_UnknownHeaderNull_UnitTest* self =
+ new(ELeave) CWspHeaderReader_UnknownHeaderNull_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_UnknownHeaderNull_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iUnknownHeaderNullValidator;
+ iUnknownHeaderNullValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_UnknownHeaderNull_UnitTest::~CWspHeaderReader_UnknownHeaderNull_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iUnknownHeaderNullValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_UnknownHeaderNull_UnitTest::CWspHeaderReader_UnknownHeaderNull_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderUnknownHeaderNullUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_UnknownHeaderNull_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(KErrNotFound);
+ iUTContext->iTestHeader->BeginRawDataL();
+ TUint8 octet00 = 0x00;
+ iUTContext->iTestHeader->WriteRawDataL(octet00);
+ iUTContext->iTestHeader->CommitRawData();
+ iUTContext->SetExpectedL(KNullDesC8());
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iUnknownHeaderNullValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iUnknownHeaderNullValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderMultiUnknownHeaderUnitTest,"CWspHeaderReader_MultiUnknownHeader_UnitTest");
+
+CWspHeaderReader_MultiUnknownHeader_UnitTest* CWspHeaderReader_MultiUnknownHeader_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_MultiUnknownHeader_UnitTest* self =
+ new(ELeave) CWspHeaderReader_MultiUnknownHeader_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_MultiUnknownHeader_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iMultiUnknownHeaderValidator;
+ iMultiUnknownHeaderValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_MultiUnknownHeader_UnitTest::~CWspHeaderReader_MultiUnknownHeader_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iMultiUnknownHeaderValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_MultiUnknownHeader_UnitTest::CWspHeaderReader_MultiUnknownHeader_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderMultiUnknownHeaderUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_MultiUnknownHeader_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(KErrNotFound);
+ _LIT8(KTxtTestData1, "First test data\0");
+ _LIT8(KTxtTestData2, "Second test data\0");
+ _LIT8(KTxtTestData3, "Third test data\0");
+ _LIT8(KTxtHeaderField, "TestHeader\0");
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTestData1());
+ iUTContext->iTestHeader->WriteRawDataL(KTxtHeaderField()); // separator
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTestData2());
+ iUTContext->iTestHeader->WriteRawDataL(KTxtHeaderField()); // separator
+ iUTContext->iTestHeader->WriteRawDataL(KTxtTestData3());
+ iUTContext->iTestHeader->CommitRawData();
+
+ _LIT8(KTxtExpected, "First test data,Second test data,Third test data");
+ iUTContext->SetExpectedL(KTxtExpected);
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iMultiUnknownHeaderValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iMultiUnknownHeaderValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProfileWarningWarnCodeUnitTest,"CWspHeaderReader_ProfileWarningWarnCode_UnitTest");
+
+CWspHeaderReader_ProfileWarningWarnCode_UnitTest* CWspHeaderReader_ProfileWarningWarnCode_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProfileWarningWarnCode_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProfileWarningWarnCode_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProfileWarningWarnCode_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProfileWarningWarnCodeValidator;
+ iProfileWarningWarnCodeValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProfileWarningWarnCode_UnitTest::~CWspHeaderReader_ProfileWarningWarnCode_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProfileWarningWarnCodeValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProfileWarningWarnCode_UnitTest::CWspHeaderReader_ProfileWarningWarnCode_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProfileWarningWarnCodeUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProfileWarningWarnCode_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProfileWarning);
+
+ TUint8 warnCode = 0x90; // Short int token for 16 (100)
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(warnCode);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "100");
+ iUTContext->SetExpectedL(KTxtExpected);
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProfileWarningWarnCodeValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProfileWarningWarnCodeValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProfileWarningWarnCodeTextWarnTargetUnitTest,"CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest");
+
+CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest* CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProfileWarningWarnCodeTextWarnTargetValidator;
+ iProfileWarningWarnCodeTextWarnTargetValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest::~CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProfileWarningWarnCodeTextWarnTargetValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest::CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProfileWarningWarnCodeTextWarnTargetUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProfileWarningWarnCodeTextWarnTarget_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProfileWarning);
+
+ TUint8 valueLength = 0x18; // length for 24 bytes
+ TUint8 warnCode = 0x92; // Short int token for 18 (102)
+ _LIT8(KTxtWarnTarget, "http://www.symbian.com\0");
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(warnCode);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnTarget());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "102,http://www.symbian.com");
+ iUTContext->SetExpectedL(KTxtExpected);
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProfileWarningWarnCodeTextWarnTargetValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProfileWarningWarnCodeTextWarnTargetValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProfileWarningWarnCodeHostWarnTargetUnitTest,"CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest");
+
+CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest* CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProfileWarningWarnCodeHostWarnTargetValidator;
+ iProfileWarningWarnCodeHostWarnTargetValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest::~CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProfileWarningWarnCodeHostWarnTargetValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest::CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProfileWarningWarnCodeHostWarnTargetUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProfileWarningWarnCodeHostWarnTarget_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProfileWarning);
+
+ TUint8 valueLength = 0x17; // length for 23 bytes
+ TUint8 warnCode = 0x91; // Short int token for 17 (101)
+ _LIT8(KTxtHostWarnTarget, "http://www.symbian.com\0");
+
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(warnCode);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtHostWarnTarget());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "101,http://www.symbian.com");
+ iUTContext->SetExpectedL(KTxtExpected);
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProfileWarningWarnCodeHostWarnTargetValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProfileWarningWarnCodeHostWarnTargetValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProfileWarningLongFullValueUnitTest,"CWspHeaderReader_ProfileWarningLongFullValue_UnitTest");
+
+CWspHeaderReader_ProfileWarningLongFullValue_UnitTest* CWspHeaderReader_ProfileWarningLongFullValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProfileWarningLongFullValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProfileWarningLongFullValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProfileWarningLongFullValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProfileWarningLongFullValueValidator;
+ iProfileWarningLongFullValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProfileWarningLongFullValue_UnitTest::~CWspHeaderReader_ProfileWarningLongFullValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProfileWarningLongFullValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProfileWarningLongFullValue_UnitTest::CWspHeaderReader_ProfileWarningLongFullValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProfileWarningLongFullValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProfileWarningLongFullValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProfileWarning);
+
+ TUint8 octet1F = 0x1F; // <Octet 31> for length quote
+ TUint8 valueLength = 0x27; // length for 39 bytes
+ TUint8 warnCode = 0xA0; // Short int token for 32 (200)
+ _LIT8(KTxtWarnTarget, "http://www.longaddresswebsite.com\0");
+ TUint8 octet03 = 0x03; // short length of 3 for date value
+ TUint8 octet255 = 0xFF; // example date value
+ TUint8 octet254 = 0xFE; // example date value
+
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(warnCode);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtWarnTarget());
+ iUTContext->iTestHeader->WriteRawDataL(octet03);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "200,http://www.longaddresswebsite.com,Tue, 14 Jul 1970 04:20:14 GMT");
+ iUTContext->SetExpectedL(KTxtExpected);
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProfileWarningLongFullValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProfileWarningLongFullValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProfileWarningLongWarnCodeHostWarnTargetUnitTest,"CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest");
+
+CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest* CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProfileWarningLongWarnCodeHostWarnTargetValidator;
+ iProfileWarningLongWarnCodeHostWarnTargetValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest::~CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProfileWarningLongWarnCodeHostWarnTargetValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest::CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProfileWarningLongWarnCodeHostWarnTargetUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTarget_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProfileWarning);
+
+ TUint8 octet1F = 0x1F; // <Octet 31> for length quote
+ TUint8 valueLength = 0x27; // length for 39 bytes
+ TUint8 warnCode = 0x90; // Short int token for 16 (100)
+ _LIT8(KTxtHostWarnTarget, "http://www.longaddresswebsite.com:9090\0");
+
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(warnCode);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtHostWarnTarget());
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "100,http://www.longaddresswebsite.com:9090");
+ iUTContext->SetExpectedL(KTxtExpected);
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProfileWarningLongWarnCodeHostWarnTargetValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProfileWarningLongWarnCodeHostWarnTargetValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KWspHeaderReaderProfileWarningLongWarnCodeHostWarnTargetDateValueUnitTest,"CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest");
+
+CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest* CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest* self =
+ new(ELeave) CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest::RunError(TInt aError)
+ {
+ // The RunL left so chain to the base first and then cleanup
+ TInt error = CUnitTest::RunError(aError); // Chain to base
+ delete iUTContext;
+ iUTContext = NULL;
+ delete iStateAccessor;
+ iStateAccessor = NULL;
+ /* delete any validators used */
+ delete iCtorValidator;
+ iCtorValidator = NULL;
+ delete iProfileWarningLongWarnCodeHostWarnTargetDateValueValidator;
+ iProfileWarningLongWarnCodeHostWarnTargetDateValueValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest::~CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iProfileWarningLongWarnCodeHostWarnTargetDateValueValidator;
+ delete iDtorValidator;
+ }
+
+inline CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest::CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KWspHeaderReaderProfileWarningLongWarnCodeHostWarnTargetDateValueUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CWspHeaderReader_ProfileWarningLongWarnCodeHostWarnTargetDateValue_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TWspHeaderReader_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CWspHeaderReader_UnitTestContext(iDataLogger, *iStateAccessor, *this, WSP::Table);
+ iUTContext->ConstructL(WSP::EProfileWarning);
+
+ TUint8 octet1F = 0x1F; // <Octet 31> for length quote
+ TUint8 valueLength = 0x27; // length for 39 bytes
+ TUint8 warnCode = 0xA1; // Short int token for 33 (201)
+ _LIT8(KTxtHostWarnTarget, "http://www.longaddresswebsite.com:80\0");
+ TUint8 octet03 = 0x03; // short length of 3 for date value
+ TUint8 octet255 = 0xFF; // example date value
+ TUint8 octet254 = 0xFE; // example date value
+
+ iUTContext->iTestHeader->BeginRawDataL();
+ iUTContext->iTestHeader->WriteRawDataL(octet1F);
+ iUTContext->iTestHeader->WriteRawDataL(valueLength);
+ iUTContext->iTestHeader->WriteRawDataL(warnCode);
+ iUTContext->iTestHeader->WriteRawDataL(KTxtHostWarnTarget());
+ iUTContext->iTestHeader->WriteRawDataL(octet03);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet255);
+ iUTContext->iTestHeader->WriteRawDataL(octet254);
+ iUTContext->iTestHeader->CommitRawData();
+ _LIT8(KTxtExpected, "201,http://www.longaddresswebsite.com:80,Tue, 14 Jul 1970 04:20:14 GMT");
+ iUTContext->SetExpectedL(KTxtExpected);
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ /* Examples of C'tor and D'tor transitions on CWspHeaderReader class.
+ using constructor and destuctor validators */
+ iCtorValidator = new(ELeave) TWspHeaderReader_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_NewL_Transition(*iUTContext,*iCtorValidator));
+ iProfileWarningLongWarnCodeHostWarnTargetDateValueValidator = new(ELeave) TWspHeaderReader_DecodeHeaderL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_DecodeHeaderL_Transition(*iUTContext,*iProfileWarningLongWarnCodeHostWarnTargetDateValueValidator));
+ iDtorValidator = new(ELeave) TWspHeaderReader_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CWspHeaderReader_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+