diff -r 7f293ed715ec -r a4835904093b LbsApi/src/requestorclassesstep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/LbsApi/src/requestorclassesstep.cpp Wed Jul 28 13:24:28 2010 +0100 @@ -0,0 +1,567 @@ +// Copyright (c) 2005-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: +// Example CTestStep derived implementation +// +// + +/** + @file RequestorClassesStep.cpp + @internalTechnology +*/ +#include "requestorclassesstep.h" +#include "te_lbsapisuitedefs.h" + +#include "lcfsbucommondefinitions.h" + +#include +#include + +#include + +CRequestorClassesStep::~CRequestorClassesStep() +/** + * Destructor + */ + { + } + +CRequestorClassesStep::CRequestorClassesStep() +/** + * Constructor + */ + { + // **MUST** call SetTestStepName in the constructor as the controlling + // framework uses the test step name immediately following construction to set + // up the step's unique logging ID. + SetTestStepName(KRequestorClassesStep); + } + +TVerdict CRequestorClassesStep::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + CTe_LbsApiSuiteStepBase::doTestStepPreambleL(); + if (TestStepResult()!=EPass) + return TestStepResult(); + // process some pre setting to this test step then set SetTestStepResult to EFail or Epass. + SetTestStepResult(EPass); + return TestStepResult(); + } + + +TVerdict CRequestorClassesStep::doTestStepL() +/** + * @return - TVerdict code + * Override of base class pure virtual + * Our implementation only gets called if the base class doTestStepPreambleL() did + * not leave. That being the case, the current test result value will be EPass. + */ + { + if (TestStepResult()==EPass) + { + TInt test; + if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test) + ) + { + // Leave if there's any error. + User::Leave(KErrNotFound); + } + SetTestStepResult(EPass); + StartL(test); + } + return TestStepResult(); + } + + + +TVerdict CRequestorClassesStep::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + // process something post setting to the test step + // uncomment the following line if you have common post setting to all the test steps in there + // CTe_LbsApiSuiteStepBase::doTestStepPostambleL(); + // uncomment the following line if you have post process or remove the following line if no post process + // SetTestStepResult(EPass); // or EFail + return TestStepResult(); + } + + +void CRequestorClassesStep::StartL (TInt aIndex) + { + switch (aIndex) + { + case 0: + RRequestorStack_StreamingL (); + break; + case 1: + RRequestorStack_Streaming2L (); + break; + case 2: + CRequestor_ConstructionL (); + break; + case 3: + CRequestor_SetL (); + break; + case 4: + CRequestor_Construction2L (); + break; + case 5: + CRequestor_StreamingL (); + break; + case 6: + CRequestor_Streaming2L (); + break; + default: + break; + } + } + + +// +// +// RRequestorStack +// +// + +void ResetAndDestroyRequestorStack(TAny* aArray) + { + RRequestorStack* stack = static_cast(aArray); + stack->ResetAndDestroy(); + } + +// 8.1.1. Streaming +void CRequestorClassesStep::RRequestorStack_StreamingL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + RRequestorStack requestorStack; + CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack)); + + _LIT(KDummyLit1, "Hello"); + const CRequestor::TRequestorType KDummyRequestorType1(CRequestor::ERequestorService); + const CRequestor::TRequestorFormat KDummyRequestorFormat1(CRequestor::EFormatTelephone); + + CRequestor* requestor = CRequestor::NewLC(KDummyRequestorType1, KDummyRequestorFormat1, KDummyLit1); + User::LeaveIfError(requestorStack.Append(requestor)); //take ownership of requestor + CleanupStack::Pop(requestor); + requestor = NULL; //Just to make it clear we don't one requestor. + + _LIT(KDummyLit2, "Goodbye"); + const CRequestor::TRequestorType KDummyRequestorType2(CRequestor::ERequestorContact); + const CRequestor::TRequestorFormat KDummyRequestorFormat2(CRequestor::EFormatUrl); + + requestor = CRequestor::NewLC(KDummyRequestorType2, KDummyRequestorFormat2, KDummyLit2); + User::LeaveIfError(requestorStack.Append(requestor)); //take ownership of requestor + CleanupStack::Pop(requestor); + requestor = NULL; //Just to make it clear we don't one requestor. + + //All info in requestorStack. Now stream out and back into a new requestor stack. + + CBufFlat* buffer = CBufFlat::NewL(512); //Abritrary size chosen + CleanupStack::PushL(buffer); + RBufWriteStream writeStream; + writeStream.Open(*buffer); + writeStream.PushL(); + // externalize + requestorStack.ExternalizeL(writeStream); + writeStream.CommitL(); + writeStream.Pop(); + //requestorStack now piped into buffer. + //get rid of requestorStack. + CleanupStack::Pop(buffer); + CleanupStack::PopAndDestroy(&requestorStack); + CleanupStack::PushL(buffer); + + RBufReadStream readStream; + readStream.Open(*buffer); + readStream.PushL(); + + RRequestorStack requestorStack2; + CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack2)); + // internalize + requestorStack2.InternalizeL(readStream); + //requestorStack2 should now be initialised. + + CHECK_EQUAL_(2, requestorStack2.Count()); + + requestor = requestorStack2[0]; + CHECK(!TPtrC(KDummyLit1).Compare(requestor->RequestorData())); + CHECK_EQUAL_(requestor->RequestorType(), KDummyRequestorType1); + CHECK_EQUAL_(requestor->RequestorFormat(), KDummyRequestorFormat1); + + requestor = requestorStack2[1]; + CHECK(!TPtrC(KDummyLit2).Compare(requestor->RequestorData())); + CHECK_EQUAL_(requestor->RequestorType(), KDummyRequestorType2); + CHECK_EQUAL_(requestor->RequestorFormat(), KDummyRequestorFormat2); + + CleanupStack::PopAndDestroy(3, buffer); + + StandardCleanup(); + } + + +// 8.1.2. Streaming with invalid stream +TInt RRequestorStack_Streaming_Invalid(TAny* /*aPtr*/) + { + RBufReadStream readStream; + + // buffer + CBufFlat* buffer = CBufFlat::NewL(512); //Arbitrary size chosen + RBufWriteStream writeStream; // make sure it is empty + writeStream.Open(*buffer); + writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorStackVersion) + writeStream.Close(); + writeStream.Release(); + + // read-stream + readStream.Open(*buffer); + + TInt err; + TRAP(err, + // internalize it + RRequestorStack requestorStack2; + CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack2)); + + requestorStack2.InternalizeL(readStream); //This should panic + + CleanupStack::Pop(); + ); + + readStream.Release(); + delete buffer; + + return KErrGeneral; + } + + +void CRequestorClassesStep::RRequestorStack_Streaming2L() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + // attempt to internalize from invalid stream + DO_PANIC_TEST_L( + RRequestorStack_Streaming_Invalid, + KPosClientFault, + EPositionInvalidClassType, + KDefaultTestTimeout); + + StandardCleanup(); + } + + +// 8.1.3. Streaming with No Memory +// See NoMemoryTests.cpp + +// +// +// CRequestor +// +// + +// 8.2.1. Construction +void CRequestorClassesStep::CRequestor_ConstructionL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + _LIT(KDummyLit, "Hello"); + const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService); + const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone); + + CRequestor* requestor = NULL; + + requestor = CRequestor::NewL(KDummyRequestorType, KDummyRequestorFormat, KDummyLit); + CHECK(requestor->RequestorData().Compare(KDummyLit) == 0); + CHECK(requestor->RequestorType() == KDummyRequestorType); + CHECK(requestor->RequestorFormat() == KDummyRequestorFormat); + delete requestor; + + requestor = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, KDummyLit); + CHECK(requestor->RequestorData().Compare(KDummyLit) == 0); + CHECK(requestor->RequestorType() == KDummyRequestorType); + CHECK(requestor->RequestorFormat() == KDummyRequestorFormat); + CleanupStack::PopAndDestroy(requestor); + + requestor = static_cast( User::LeaveIfNull(CRequestor::New(KDummyRequestorType, KDummyRequestorFormat, KDummyLit))); + CHECK(requestor->RequestorData().Compare(KDummyLit) == 0); + CHECK(requestor->RequestorType() == KDummyRequestorType); + CHECK(requestor->RequestorFormat() == KDummyRequestorFormat); + delete requestor; + + StandardCleanup(); + } + + +// 8.2.2. Setters and Getters +void CRequestorClassesStep::CRequestor_SetL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + // Get + _LIT(KDummyLit, "Hello"); + const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService); + const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone); + CRequestor* requestor = CRequestor::NewL(KDummyRequestorType, KDummyRequestorFormat, KDummyLit); + CleanupStack::PushL(requestor); + + TPtrC ptr; + CRequestor::TRequestorType requestorType; + CRequestor::TRequestorFormat requestorFormat; + + requestor->GetRequestor(requestorType, requestorFormat, ptr); + + CHECK(ptr.Compare(KDummyLit) == 0); + CHECK(requestorType == KDummyRequestorType); + CHECK(requestorFormat == KDummyRequestorFormat); + + // Set + _LIT(KNewDummyLit, "Goodbye"); + const CRequestor::TRequestorType KNewDummyRequestorType(CRequestor::ERequestorContact); + const CRequestor::TRequestorFormat KNewDummyRequestorFormat(CRequestor::EFormatUrl); + requestor->SetRequestorL(KNewDummyRequestorType, KNewDummyRequestorFormat, KNewDummyLit); + + // check as properties + CHECK(requestor->RequestorData().Compare(KNewDummyLit) == 0); + CHECK(requestor->RequestorType() == KNewDummyRequestorType); + CHECK(requestor->RequestorFormat() == KNewDummyRequestorFormat); + + // check by GetRequestor + requestor->GetRequestor(requestorType, requestorFormat, ptr); + + CHECK(ptr.Compare(KNewDummyLit) == 0); + CHECK(requestorType == KNewDummyRequestorType); + CHECK(requestorFormat == KNewDummyRequestorFormat); + + CleanupStack::PopAndDestroy(); + + // Now set much longer requestor data, to check if + // doesn't matter :-) + TBuf<1> shortData; + shortData.Append('$'); + requestor = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, shortData); + + TBuf<512> longData; + longData.Fill('@', longData.MaxLength()); + requestor->SetRequestorL(KNewDummyRequestorType, KNewDummyRequestorFormat, longData); + + // check it + CHECK(requestor->RequestorData().Compare(longData) == 0); + CHECK(requestor->RequestorType() == KNewDummyRequestorType); + CHECK(requestor->RequestorFormat() == KNewDummyRequestorFormat); + + // set smaller one again + requestor->SetRequestorL(KDummyRequestorType, KDummyRequestorFormat, shortData); + CHECK(requestor->RequestorData().Compare(shortData) == 0); + + CleanupStack::PopAndDestroy(); + + StandardCleanup(); + } + + +/* +// 8.2.3. Constructors with invalid parameters +void CRequestorClassesStep::CRequestor_Construction3L() +{ + // there are no relevant parameters to pass invalid values. + // the only one is wrong stream, see 8.3.4 CRequestor_Streaming_Invalid +} +*/ + +// 8.2.4. Constructors with No Memory +// See NoMemoryTests.cpp + +// 8.2.5. SetRequestor with No Memory +// See NoMemoryTests.cpp + + +// 8.3.1. Construction from stream +void CRequestorClassesStep::CRequestor_Construction2L() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + _LIT(KDummyLit, "Hello"); + const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService); + const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone); + CRequestor* requestor1 = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, KDummyLit); + + //Make a write stream + HBufC8* buffer = HBufC8::NewLC(0x100); //Should be plenty big enough + TPtr8 ptr = buffer->Des(); + RDesWriteStream writeStream(ptr); //Opens the write stream + CleanupClosePushL(writeStream); + requestor1->ExternalizeL(writeStream); + writeStream.CommitL(); + CleanupStack::PopAndDestroy(&writeStream); //Close the write stream + + //Make a read stream + RDesReadStream readStream(*buffer); + CleanupClosePushL(readStream); + + // construct + CRequestor* requestor2 = CRequestor::NewL(readStream); + + CHECK(!TPtrC(KDummyLit).Compare(requestor2->RequestorData())); + CHECK_EQUAL_(requestor2->RequestorType(), KDummyRequestorType); + CHECK_EQUAL_(requestor2->RequestorFormat(), KDummyRequestorFormat); + + delete requestor2; + CleanupStack::PopAndDestroy(3, requestor1); //readStream, buffer, requestor1 + + StandardCleanup(); + } + + +// 8.3.2. Externalize/Internalize +void CRequestorClassesStep::CRequestor_StreamingL() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + _LIT(KDummyLit1, "Hello"); + const CRequestor::TRequestorType KDummyRequestorType1(CRequestor::ERequestorService); + const CRequestor::TRequestorFormat KDummyRequestorFormat1(CRequestor::EFormatTelephone); + CRequestor* requestor1 = CRequestor::NewLC(KDummyRequestorType1, KDummyRequestorFormat1, KDummyLit1); + + // set r2 with other values + _LIT(KDummyLit2, "Goodbye"); + const CRequestor::TRequestorType KDummyRequestorType2(CRequestor::ERequestorContact); + const CRequestor::TRequestorFormat KDummyRequestorFormat2(CRequestor::EFormatUrl); + CRequestor* requestor2 = CRequestor::NewLC(KDummyRequestorType2, KDummyRequestorFormat2, KDummyLit2); + + // Make a write stream + HBufC8* buffer = HBufC8::NewLC(0x100); //Should be plenty big enough + TPtr8 ptr = buffer->Des(); + RDesWriteStream writeStream(ptr); //Opens the write stream + CleanupClosePushL(writeStream); + + // externalize r1 + writeStream << *requestor1; + writeStream.CommitL(); + CleanupStack::PopAndDestroy(&writeStream); //Close the write stream + + RDesReadStream readStream(*buffer); + CleanupClosePushL(readStream); + // internalize r2 + requestor2->InternalizeL(readStream); + CleanupStack::PopAndDestroy(&readStream); //Close the readStream + + // check r2 + CHECK(requestor2->RequestorData().Compare(KDummyLit1) == 0); + CHECK(requestor2->RequestorType() == KDummyRequestorType1); + CHECK(requestor2->RequestorFormat() == KDummyRequestorFormat1); + + CleanupStack::PopAndDestroy(3, requestor1); + + StandardCleanup(); + } + + +// 8.3.3. Streaming with NoMemory +// See NoMemoryTests.cpp + +// 8.3.4. Invalid stream +TInt CRequestor_Internalize_Invalid_Stream(TAny* /*aPtr*/) + { + CRequestor* requestor = NULL; + RBufReadStream readStream; + + // buffer + CBufFlat* buffer = CBufFlat::NewL(512); //Abritrary size chosen + RBufWriteStream writeStream; // make sure it is empty + writeStream.Open(*buffer); + writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorVersion) + writeStream.Close(); + writeStream.Release(); + readStream.Open(*buffer); + + TInt err; + TRAP(err, + // internalize it + requestor = CRequestor::New(DUMMY_REQUESTOR_TYPE_ACCEPTED1, DUMMY_REQUESTOR_FORMAT_ACCEPTED1, DUMMY_REQUESTOR_NAME_ACCEPTED1); + CleanupStack::PushL(requestor); + + requestor->InternalizeL(readStream); //This should panic + + CleanupStack::PopAndDestroy(); + ); + User::LeaveIfError(err); + + readStream.Release(); + delete buffer; + + return KErrGeneral; + } + + +TInt CRequestor_Construct_Invalid_Stream(TAny* /*aPtr*/) + { + CRequestor* requestor = NULL; + RBufReadStream readStream; + + // buffer + CBufFlat* buffer = CBufFlat::NewL(512); //Arbitrary size chosen + RBufWriteStream writeStream; // make sure it is empty + writeStream.Open(*buffer); + writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorVersion) + writeStream.Close(); + writeStream.Release(); + + // read-stream + readStream.Open(*buffer); + + TInt err; + TRAP(err, + // internalize it + requestor = CRequestor::NewL(readStream); //This should panic + ); + + delete requestor; + readStream.Release(); + delete buffer; + + return KErrGeneral; + } + + +void CRequestorClassesStep::CRequestor_Streaming2L() + { + DECLARE_ERROR_LOGGING; + StandardPrepareL(); + + // attempt to internalize from invalid stream + DO_PANIC_TEST_L( + CRequestor_Internalize_Invalid_Stream, + KPosClientFault, + EPositionInvalidClassType, + KDefaultTestTimeout); + // attempt to construct from invalid stream + DO_PANIC_TEST_L( + CRequestor_Construct_Invalid_Stream, + KPosClientFault, + EPositionInvalidClassType, + KDefaultTestTimeout); + + StandardCleanup(); + } +