diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Test_Bed/TransitionTest/TransitionUnitTest.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/lowlevellibsandfws/pluginfw/Test_Bed/TransitionTest/TransitionUnitTest.cpp Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,295 @@
+// 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 CTransition class.
+//
+//
+
+#include "TransitionUnitTest.h"
+
+// ______________________________________________________________________________
+//
+_LIT(KTransitionCreateAndDestroyUnitTest,"CTransition_CreateAndDestroy_UnitTest");
+
+CTransition_CreateAndDestroy_UnitTest* CTransition_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CTransition_CreateAndDestroy_UnitTest* self =
+ new(ELeave) CTransition_CreateAndDestroy_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CTransition_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 CTransition_CreateAndDestroy_UnitTest::~CTransition_CreateAndDestroy_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iDtorValidator;
+ }
+
+inline CTransition_CreateAndDestroy_UnitTest::CTransition_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KTransitionCreateAndDestroyUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CTransition_CreateAndDestroy_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TTransition_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
+
+ // Provide a valid context and validator for the target transition class under test.
+ iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
+ iUTContext->iTargetValidator = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
+
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));
+
+ iDtorValidator = new(ELeave) TTransition_Dtor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }
+
+// ______________________________________________________________________________
+//
+_LIT(KTransitionTransitMethodLUnitTest,"CTransition_TransitMethodL_UnitTest");
+
+CTransition_TransitMethodL_UnitTest* CTransition_TransitMethodL_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CTransition_TransitMethodL_UnitTest* self =
+ new(ELeave) CTransition_TransitMethodL_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CTransition_TransitMethodL_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 iTransitMethodLValidator;
+ iTransitMethodLValidator = NULL;
+ delete iRepeatOnceValidator;
+ iRepeatOnceValidator = NULL;
+ delete iTransitionIdValidator;
+ iTransitionIdValidator = NULL;
+ delete iTransitionInfoValidator;
+ iTransitionInfoValidator = NULL;
+ delete iIsBlockingValidator;
+ iIsBlockingValidator = NULL;
+ delete iSetBlockingValidator;
+ iSetBlockingValidator = NULL;
+ delete iTransitMethodLValidator;
+ iTransitMethodLValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CTransition_TransitMethodL_UnitTest::~CTransition_TransitMethodL_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iTransitionIdValidator;
+ delete iTransitionInfoValidator;
+ delete iIsBlockingValidator;
+ delete iSetBlockingValidator;
+ delete iTransitMethodLValidator;
+ delete iRepeatOnceValidator;
+ delete iDtorValidator;
+ }
+
+inline CTransition_TransitMethodL_UnitTest::CTransition_TransitMethodL_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KTransitionTransitMethodLUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CTransition_TransitMethodL_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TTransition_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
+ // Provide a valid context and validator for the target transition class under test.
+ iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
+ iUTContext->iTargetValidator = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
+ // Add the Transitions in the order they are to run
+ // C'tor first, D'tor last...
+ iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));
+
+ // Test the flag setting
+ iTransitionIdValidator = new(ELeave) TTransition_TransitionId_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_TransitionId_Transition(*iUTContext,*iTransitionIdValidator));
+ iTransitionInfoValidator = new(ELeave) TTransition_TransitionInfo_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_TransitionInfo_Transition(*iUTContext,*iTransitionInfoValidator));
+ iIsBlockingValidator = new(ELeave) TTransition_IsBlocking_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
+ iSetBlockingValidator = new(ELeave) TTransition_SetBlocking_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_SetBlocking_Transition(*iUTContext,*iSetBlockingValidator));
+ AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
+ AddTransitionL(new(ELeave)CTransition_SetBlocking_Transition(*iUTContext,*iSetBlockingValidator));
+ AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
+
+ // The transit
+ iTransitMethodLValidator = new(ELeave) TTransition_TransitMethodL_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_TransitMethodL_Transition(*iUTContext,*iTransitMethodLValidator));
+ // The repeat flag
+ iRepeatOnceValidator = new(ELeave) TTransition_RepeatOnce_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_RepeatOnce_Transition(*iUTContext,*iRepeatOnceValidator));
+ AddTransitionL(new(ELeave)CTransition_TransitMethodL_Transition(*iUTContext,*iTransitMethodLValidator));
+ // We are expecting the Abort code on the repeat call So no dtor required.
+ AddLeaveErrorCodeL(KErrAbort);
+ }
+
+
+// ______________________________________________________________________________
+//
+_LIT(KTransitionAsyncOperationUnitTest,"CTransition_AsyncOperation_UnitTest");
+
+CTransition_AsyncOperation_UnitTest* CTransition_AsyncOperation_UnitTest::NewL(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+ {
+ CTransition_AsyncOperation_UnitTest* self =
+ new(ELeave) CTransition_AsyncOperation_UnitTest(aDataLogger,
+ aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+inline TInt CTransition_AsyncOperation_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 iRunTransitionValidator;
+ iRunTransitionValidator = NULL;
+ delete iCancelValidator;
+ iCancelValidator = NULL;
+ delete iGetErrorCodeValidator;
+ iGetErrorCodeValidator = NULL;
+ delete iDtorValidator;
+ iDtorValidator = NULL;
+ return error;
+ }
+
+inline CTransition_AsyncOperation_UnitTest::~CTransition_AsyncOperation_UnitTest()
+ {
+ // Simply delete our test class instance
+ delete iUTContext;
+ delete iStateAccessor;
+ /* delete any validators used */
+ delete iCtorValidator;
+ delete iRunTransitionValidator;
+ delete iCancelValidator;
+ delete iGetErrorCodeValidator;
+ delete iDtorValidator;
+ }
+
+inline CTransition_AsyncOperation_UnitTest::CTransition_AsyncOperation_UnitTest(CDataLogger& aDataLogger,
+ MUnitTestObserver& aObserver)
+: CUnitTest(KTransitionAsyncOperationUnitTest, aDataLogger, aObserver)
+ {
+ //Do nothing
+ }
+
+// Now the Individual transitions need to be added.
+inline void CTransition_AsyncOperation_UnitTest::ConstructL()
+ {
+ // Perform the base class initialization
+ UnitTestConstructL();
+
+ // Create the Unit test state accessor
+ iStateAccessor = new(ELeave) TTransition_StateAccessor;
+ // Construct the Unit test context.
+ iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
+ // Provide a valid context and validator for the target transition class under test.
+ iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
+ iUTContext->iTargetValidator = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
+ // 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 CTransition class.
+ using ctor and dtor validators */
+ iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));
+
+ // Run the target transition asynchronously, cancel, check the error code,
+ // and then run asynchronously again to completion
+ iRunTransitionValidator = new(ELeave) TTransition_RunTransition_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_RunTransition_Transition(*iUTContext,*iRunTransitionValidator));
+ iCancelValidator = new(ELeave) TTransition_Cancel_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_Cancel_Transition(*iUTContext,*iRunTransitionValidator));
+ iGetErrorCodeValidator = new(ELeave) TTransition_GetErrorCode_TransitionValidator(*iUTContext);
+ AddTransitionL(new(ELeave)CTransition_GetErrorCode_Transition(*iUTContext,*iGetErrorCodeValidator));
+ AddTransitionL(new(ELeave)CTransition_RunTransition_Transition(*iUTContext,*iRunTransitionValidator));
+
+ iDtorValidator = new(ELeave) TTransition_Dtor_TransitionValidator(*iUTContext);
+ AddBlockingTransitionL(new(ELeave)CTransition_Dtor_Transition(*iUTContext,*iDtorValidator));
+ }