os/ossrv/lowlevellibsandfws/pluginfw/Test_Bed/TransitionTest/TransitionUnitTest.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Test_Bed/TransitionTest/TransitionUnitTest.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,295 @@
1.4 +// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// The unit test class implementations for the CTransition class.
1.18 +//
1.19 +//
1.20 +
1.21 +#include "TransitionUnitTest.h"
1.22 +
1.23 +// ______________________________________________________________________________
1.24 +//
1.25 +_LIT(KTransitionCreateAndDestroyUnitTest,"CTransition_CreateAndDestroy_UnitTest");
1.26 +
1.27 +CTransition_CreateAndDestroy_UnitTest* CTransition_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,
1.28 + MUnitTestObserver& aObserver)
1.29 + {
1.30 + CTransition_CreateAndDestroy_UnitTest* self =
1.31 + new(ELeave) CTransition_CreateAndDestroy_UnitTest(aDataLogger,
1.32 + aObserver);
1.33 + CleanupStack::PushL(self);
1.34 + self->ConstructL();
1.35 + CleanupStack::Pop(self);
1.36 + return self;
1.37 + }
1.38 +
1.39 +inline TInt CTransition_CreateAndDestroy_UnitTest::RunError(TInt aError)
1.40 + {
1.41 + // The RunL left so chain to the base first and then cleanup
1.42 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.43 + delete iUTContext;
1.44 + iUTContext = NULL;
1.45 + delete iStateAccessor;
1.46 + iStateAccessor = NULL;
1.47 + /* delete any validators used */
1.48 + delete iCtorValidator;
1.49 + iCtorValidator = NULL;
1.50 + delete iDtorValidator;
1.51 + iDtorValidator = NULL;
1.52 + return error;
1.53 + }
1.54 +
1.55 +inline CTransition_CreateAndDestroy_UnitTest::~CTransition_CreateAndDestroy_UnitTest()
1.56 + {
1.57 + // Simply delete our test class instance
1.58 + delete iUTContext;
1.59 + delete iStateAccessor;
1.60 + /* delete any validators used */
1.61 + delete iCtorValidator;
1.62 + delete iDtorValidator;
1.63 + }
1.64 +
1.65 +inline CTransition_CreateAndDestroy_UnitTest::CTransition_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,
1.66 + MUnitTestObserver& aObserver)
1.67 +: CUnitTest(KTransitionCreateAndDestroyUnitTest, aDataLogger, aObserver)
1.68 + {
1.69 + //Do nothing
1.70 + }
1.71 +
1.72 +// Now the Individual transitions need to be added.
1.73 +inline void CTransition_CreateAndDestroy_UnitTest::ConstructL()
1.74 + {
1.75 + // Perform the base class initialization
1.76 + UnitTestConstructL();
1.77 +
1.78 + // Create the Unit test state accessor
1.79 + iStateAccessor = new(ELeave) TTransition_StateAccessor;
1.80 + // Construct the Unit test context.
1.81 + iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.82 +
1.83 + // Provide a valid context and validator for the target transition class under test.
1.84 + iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.85 + iUTContext->iTargetValidator = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
1.86 +
1.87 + // Add the Transitions in the order they are to run
1.88 + // C'tor first, D'tor last...
1.89 + iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
1.90 + AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));
1.91 +
1.92 + iDtorValidator = new(ELeave) TTransition_Dtor_TransitionValidator(*iUTContext);
1.93 + AddTransitionL(new(ELeave)CTransition_Dtor_Transition(*iUTContext,*iDtorValidator));
1.94 + }
1.95 +
1.96 +// ______________________________________________________________________________
1.97 +//
1.98 +_LIT(KTransitionTransitMethodLUnitTest,"CTransition_TransitMethodL_UnitTest");
1.99 +
1.100 +CTransition_TransitMethodL_UnitTest* CTransition_TransitMethodL_UnitTest::NewL(CDataLogger& aDataLogger,
1.101 + MUnitTestObserver& aObserver)
1.102 + {
1.103 + CTransition_TransitMethodL_UnitTest* self =
1.104 + new(ELeave) CTransition_TransitMethodL_UnitTest(aDataLogger,
1.105 + aObserver);
1.106 + CleanupStack::PushL(self);
1.107 + self->ConstructL();
1.108 + CleanupStack::Pop(self);
1.109 + return self;
1.110 + }
1.111 +
1.112 +inline TInt CTransition_TransitMethodL_UnitTest::RunError(TInt aError)
1.113 + {
1.114 + // The RunL left so chain to the base first and then cleanup
1.115 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.116 + delete iUTContext;
1.117 + iUTContext = NULL;
1.118 + delete iStateAccessor;
1.119 + iStateAccessor = NULL;
1.120 + /* delete any validators used */
1.121 + delete iCtorValidator;
1.122 + iCtorValidator = NULL;
1.123 + delete iTransitMethodLValidator;
1.124 + iTransitMethodLValidator = NULL;
1.125 + delete iRepeatOnceValidator;
1.126 + iRepeatOnceValidator = NULL;
1.127 + delete iTransitionIdValidator;
1.128 + iTransitionIdValidator = NULL;
1.129 + delete iTransitionInfoValidator;
1.130 + iTransitionInfoValidator = NULL;
1.131 + delete iIsBlockingValidator;
1.132 + iIsBlockingValidator = NULL;
1.133 + delete iSetBlockingValidator;
1.134 + iSetBlockingValidator = NULL;
1.135 + delete iTransitMethodLValidator;
1.136 + iTransitMethodLValidator = NULL;
1.137 + delete iDtorValidator;
1.138 + iDtorValidator = NULL;
1.139 + return error;
1.140 + }
1.141 +
1.142 +inline CTransition_TransitMethodL_UnitTest::~CTransition_TransitMethodL_UnitTest()
1.143 + {
1.144 + // Simply delete our test class instance
1.145 + delete iUTContext;
1.146 + delete iStateAccessor;
1.147 + /* delete any validators used */
1.148 + delete iCtorValidator;
1.149 + delete iTransitionIdValidator;
1.150 + delete iTransitionInfoValidator;
1.151 + delete iIsBlockingValidator;
1.152 + delete iSetBlockingValidator;
1.153 + delete iTransitMethodLValidator;
1.154 + delete iRepeatOnceValidator;
1.155 + delete iDtorValidator;
1.156 + }
1.157 +
1.158 +inline CTransition_TransitMethodL_UnitTest::CTransition_TransitMethodL_UnitTest(CDataLogger& aDataLogger,
1.159 + MUnitTestObserver& aObserver)
1.160 +: CUnitTest(KTransitionTransitMethodLUnitTest, aDataLogger, aObserver)
1.161 + {
1.162 + //Do nothing
1.163 + }
1.164 +
1.165 +// Now the Individual transitions need to be added.
1.166 +inline void CTransition_TransitMethodL_UnitTest::ConstructL()
1.167 + {
1.168 + // Perform the base class initialization
1.169 + UnitTestConstructL();
1.170 +
1.171 + // Create the Unit test state accessor
1.172 + iStateAccessor = new(ELeave) TTransition_StateAccessor;
1.173 + // Construct the Unit test context.
1.174 + iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.175 + // Provide a valid context and validator for the target transition class under test.
1.176 + iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.177 + iUTContext->iTargetValidator = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
1.178 + // Add the Transitions in the order they are to run
1.179 + // C'tor first, D'tor last...
1.180 + iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
1.181 + AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));
1.182 +
1.183 + // Test the flag setting
1.184 + iTransitionIdValidator = new(ELeave) TTransition_TransitionId_TransitionValidator(*iUTContext);
1.185 + AddTransitionL(new(ELeave)CTransition_TransitionId_Transition(*iUTContext,*iTransitionIdValidator));
1.186 + iTransitionInfoValidator = new(ELeave) TTransition_TransitionInfo_TransitionValidator(*iUTContext);
1.187 + AddTransitionL(new(ELeave)CTransition_TransitionInfo_Transition(*iUTContext,*iTransitionInfoValidator));
1.188 + iIsBlockingValidator = new(ELeave) TTransition_IsBlocking_TransitionValidator(*iUTContext);
1.189 + AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
1.190 + iSetBlockingValidator = new(ELeave) TTransition_SetBlocking_TransitionValidator(*iUTContext);
1.191 + AddTransitionL(new(ELeave)CTransition_SetBlocking_Transition(*iUTContext,*iSetBlockingValidator));
1.192 + AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
1.193 + AddTransitionL(new(ELeave)CTransition_SetBlocking_Transition(*iUTContext,*iSetBlockingValidator));
1.194 + AddTransitionL(new(ELeave)CTransition_IsBlocking_Transition(*iUTContext,*iIsBlockingValidator));
1.195 +
1.196 + // The transit
1.197 + iTransitMethodLValidator = new(ELeave) TTransition_TransitMethodL_TransitionValidator(*iUTContext);
1.198 + AddTransitionL(new(ELeave)CTransition_TransitMethodL_Transition(*iUTContext,*iTransitMethodLValidator));
1.199 + // The repeat flag
1.200 + iRepeatOnceValidator = new(ELeave) TTransition_RepeatOnce_TransitionValidator(*iUTContext);
1.201 + AddTransitionL(new(ELeave)CTransition_RepeatOnce_Transition(*iUTContext,*iRepeatOnceValidator));
1.202 + AddTransitionL(new(ELeave)CTransition_TransitMethodL_Transition(*iUTContext,*iTransitMethodLValidator));
1.203 + // We are expecting the Abort code on the repeat call So no dtor required.
1.204 + AddLeaveErrorCodeL(KErrAbort);
1.205 + }
1.206 +
1.207 +
1.208 +// ______________________________________________________________________________
1.209 +//
1.210 +_LIT(KTransitionAsyncOperationUnitTest,"CTransition_AsyncOperation_UnitTest");
1.211 +
1.212 +CTransition_AsyncOperation_UnitTest* CTransition_AsyncOperation_UnitTest::NewL(CDataLogger& aDataLogger,
1.213 + MUnitTestObserver& aObserver)
1.214 + {
1.215 + CTransition_AsyncOperation_UnitTest* self =
1.216 + new(ELeave) CTransition_AsyncOperation_UnitTest(aDataLogger,
1.217 + aObserver);
1.218 + CleanupStack::PushL(self);
1.219 + self->ConstructL();
1.220 + CleanupStack::Pop(self);
1.221 + return self;
1.222 + }
1.223 +
1.224 +inline TInt CTransition_AsyncOperation_UnitTest::RunError(TInt aError)
1.225 + {
1.226 + // The RunL left so chain to the base first and then cleanup
1.227 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.228 + delete iUTContext;
1.229 + iUTContext = NULL;
1.230 + delete iStateAccessor;
1.231 + iStateAccessor = NULL;
1.232 + /* delete any validators used */
1.233 + delete iCtorValidator;
1.234 + iCtorValidator = NULL;
1.235 + delete iRunTransitionValidator;
1.236 + iRunTransitionValidator = NULL;
1.237 + delete iCancelValidator;
1.238 + iCancelValidator = NULL;
1.239 + delete iGetErrorCodeValidator;
1.240 + iGetErrorCodeValidator = NULL;
1.241 + delete iDtorValidator;
1.242 + iDtorValidator = NULL;
1.243 + return error;
1.244 + }
1.245 +
1.246 +inline CTransition_AsyncOperation_UnitTest::~CTransition_AsyncOperation_UnitTest()
1.247 + {
1.248 + // Simply delete our test class instance
1.249 + delete iUTContext;
1.250 + delete iStateAccessor;
1.251 + /* delete any validators used */
1.252 + delete iCtorValidator;
1.253 + delete iRunTransitionValidator;
1.254 + delete iCancelValidator;
1.255 + delete iGetErrorCodeValidator;
1.256 + delete iDtorValidator;
1.257 + }
1.258 +
1.259 +inline CTransition_AsyncOperation_UnitTest::CTransition_AsyncOperation_UnitTest(CDataLogger& aDataLogger,
1.260 + MUnitTestObserver& aObserver)
1.261 +: CUnitTest(KTransitionAsyncOperationUnitTest, aDataLogger, aObserver)
1.262 + {
1.263 + //Do nothing
1.264 + }
1.265 +
1.266 +// Now the Individual transitions need to be added.
1.267 +inline void CTransition_AsyncOperation_UnitTest::ConstructL()
1.268 + {
1.269 + // Perform the base class initialization
1.270 + UnitTestConstructL();
1.271 +
1.272 + // Create the Unit test state accessor
1.273 + iStateAccessor = new(ELeave) TTransition_StateAccessor;
1.274 + // Construct the Unit test context.
1.275 + iUTContext = new(ELeave) CTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.276 + // Provide a valid context and validator for the target transition class under test.
1.277 + iUTContext->iTargetContext = new(ELeave) CTargetTransition_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.278 + iUTContext->iTargetValidator = new(ELeave) TTransition_NULL_TransitionValidator(*(iUTContext->iTargetContext));
1.279 + // Add the Transitions in the order they are to run
1.280 + // C'tor first, D'tor last...
1.281 + /* Examples of C'tor and D'tor transitions on CTransition class.
1.282 + using ctor and dtor validators */
1.283 + iCtorValidator = new(ELeave) TTransition_Ctor_TransitionValidator(*iUTContext);
1.284 + AddTransitionL(new(ELeave)CTransition_NewL_Transition(*iUTContext,*iCtorValidator));
1.285 +
1.286 + // Run the target transition asynchronously, cancel, check the error code,
1.287 + // and then run asynchronously again to completion
1.288 + iRunTransitionValidator = new(ELeave) TTransition_RunTransition_TransitionValidator(*iUTContext);
1.289 + AddTransitionL(new(ELeave)CTransition_RunTransition_Transition(*iUTContext,*iRunTransitionValidator));
1.290 + iCancelValidator = new(ELeave) TTransition_Cancel_TransitionValidator(*iUTContext);
1.291 + AddTransitionL(new(ELeave)CTransition_Cancel_Transition(*iUTContext,*iRunTransitionValidator));
1.292 + iGetErrorCodeValidator = new(ELeave) TTransition_GetErrorCode_TransitionValidator(*iUTContext);
1.293 + AddTransitionL(new(ELeave)CTransition_GetErrorCode_Transition(*iUTContext,*iGetErrorCodeValidator));
1.294 + AddTransitionL(new(ELeave)CTransition_RunTransition_Transition(*iUTContext,*iRunTransitionValidator));
1.295 +
1.296 + iDtorValidator = new(ELeave) TTransition_Dtor_TransitionValidator(*iUTContext);
1.297 + AddBlockingTransitionL(new(ELeave)CTransition_Dtor_Transition(*iUTContext,*iDtorValidator));
1.298 + }