1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/FrameTests/MagicUnitTests.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,564 @@
1.4 +// Copyright (c) 1997-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 +// This file contains the definition of the
1.18 +// class CAllTransitionsUnitTest
1.19 +// Note : All the REComSession references from this file
1.20 +// These are simple fudges for early development tests
1.21 +// before the true server migration of the code.
1.22 +//
1.23 +//
1.24 +
1.25 +#include <e32uid.h>
1.26 +
1.27 +#include "TestUtilities.h" // For __FILE__LINE__
1.28 +#include "Interface.h"
1.29 +#include <ecom/test_bed/datalogger.h>
1.30 +
1.31 +#include "MagicUnitTests.h"
1.32 +#include "MagicTransitions.h"
1.33 +#include "MagicTransitionValidation.h"
1.34 +
1.35 +#include "TlsData.h" // For GlobalData
1.36 +
1.37 +#define UNUSED_VAR(a) a = a
1.38 +
1.39 +// ______________________________________________________________________________
1.40 +//
1.41 +_LIT(KInterfaceCreateAndDestroyUnitTest,"CExampleInterfaceCreateAndDestroyUnitTest");
1.42 +
1.43 +CExampleInterfaceCreateAndDestroyUnitTest* CExampleInterfaceCreateAndDestroyUnitTest::NewL(CDataLogger& aDataLogger,
1.44 + MUnitTestObserver& aObserver)
1.45 + {
1.46 + CExampleInterfaceCreateAndDestroyUnitTest* self =
1.47 + new(ELeave) CExampleInterfaceCreateAndDestroyUnitTest(aDataLogger,
1.48 + aObserver);
1.49 + CleanupStack::PushL(self);
1.50 + // Chain to the base which calls the ConstructL
1.51 + self->ConstructL();
1.52 + CleanupStack::Pop();
1.53 + return self;
1.54 + }
1.55 +
1.56 +TInt CExampleInterfaceCreateAndDestroyUnitTest::RunError(TInt aError)
1.57 + {
1.58 + // The RunL left so chain to the base first and then cleanup
1.59 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.60 + delete iUTContext;
1.61 + iUTContext = NULL;
1.62 + delete iStateAccessor;
1.63 + iStateAccessor = NULL;
1.64 + delete iCtorValidator;
1.65 + delete iDtorValidator;
1.66 + iCtorValidator = 0;
1.67 + iDtorValidator = 0;
1.68 +
1.69 + return error;
1.70 + }
1.71 +
1.72 +CExampleInterfaceCreateAndDestroyUnitTest::~CExampleInterfaceCreateAndDestroyUnitTest()
1.73 + {
1.74 + // Simply delete our test class instance
1.75 + delete iUTContext;
1.76 + delete iStateAccessor;
1.77 + delete iCtorValidator;
1.78 + delete iDtorValidator;
1.79 +
1.80 + }
1.81 +
1.82 +CExampleInterfaceCreateAndDestroyUnitTest::CExampleInterfaceCreateAndDestroyUnitTest(CDataLogger& aDataLogger,
1.83 + MUnitTestObserver& aObserver)
1.84 +: CUnitTest(KInterfaceCreateAndDestroyUnitTest, aDataLogger, aObserver)
1.85 + {
1.86 + //Do nothing
1.87 + }
1.88 +
1.89 +// Now the Individual transitions need to be added.
1.90 +void CExampleInterfaceCreateAndDestroyUnitTest::ConstructL()
1.91 + {
1.92 + // Perform the base class initialization
1.93 + UnitTestConstructL();
1.94 +
1.95 + // Create the Unit test state accessor
1.96 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor();
1.97 +
1.98 + // context
1.99 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.100 +
1.101 + // Add the Transitions in the order they are to run
1.102 + // C'tor first, D'tor last...
1.103 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.104 + AddTransitionL(new(ELeave)CExampleInterfaceNewLTransition(*iUTContext,*iCtorValidator));
1.105 +
1.106 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.107 + AddTransitionL(new(ELeave)CExampleInterfaceDtorTransition(*iUTContext,*iDtorValidator));
1.108 + }
1.109 +// ______________________________________________________________________________
1.110 +//
1.111 +_LIT(KExampleInterfaceAltCreateAndDestroyUnitTest,"CExampleInterfaceAltCreateAndDestroyUnitTest");
1.112 +
1.113 +CExampleInterfaceAltCreateAndDestroyUnitTest* CExampleInterfaceAltCreateAndDestroyUnitTest::NewL(CDataLogger& aDataLogger,
1.114 + MUnitTestObserver& aObserver)
1.115 + {
1.116 + CExampleInterfaceAltCreateAndDestroyUnitTest* self =
1.117 + new(ELeave) CExampleInterfaceAltCreateAndDestroyUnitTest(aDataLogger,
1.118 + aObserver);
1.119 + CleanupStack::PushL(self);
1.120 + // Chain to the base which calls the ConstructL
1.121 + self->ConstructL();
1.122 + CleanupStack::Pop(self);
1.123 + return self;
1.124 + }
1.125 +
1.126 +TInt CExampleInterfaceAltCreateAndDestroyUnitTest::RunError(TInt aError)
1.127 + {
1.128 + // The RunL left so chain to the base first and then cleanup
1.129 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.130 + delete iUTContext;
1.131 + iUTContext = NULL;
1.132 + delete iStateAccessor;
1.133 + iStateAccessor = NULL;
1.134 + delete iCtorValidator;
1.135 + iCtorValidator = NULL;
1.136 + delete iDtorValidator;
1.137 + iDtorValidator = NULL;
1.138 +
1.139 + return error;
1.140 + }
1.141 +
1.142 +CExampleInterfaceAltCreateAndDestroyUnitTest::~CExampleInterfaceAltCreateAndDestroyUnitTest()
1.143 + {
1.144 + // Simply delete our test class instance
1.145 + delete iUTContext;
1.146 + delete iStateAccessor;
1.147 + delete iCtorValidator;
1.148 + delete iDtorValidator;
1.149 +
1.150 + }
1.151 +
1.152 +CExampleInterfaceAltCreateAndDestroyUnitTest::CExampleInterfaceAltCreateAndDestroyUnitTest(CDataLogger& aDataLogger,
1.153 + MUnitTestObserver& aObserver)
1.154 +: CUnitTest(KExampleInterfaceAltCreateAndDestroyUnitTest, aDataLogger, aObserver)
1.155 + {
1.156 + //Do nothing
1.157 + }
1.158 +
1.159 +// Now the Individual transitions need to be added.
1.160 +void CExampleInterfaceAltCreateAndDestroyUnitTest::ConstructL()
1.161 + {
1.162 + // Perform the base class initialization
1.163 + UnitTestConstructL();
1.164 +
1.165 + // Create the Unit test state accessor
1.166 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor();
1.167 + // context
1.168 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.169 +
1.170 + // Create the required validators
1.171 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.172 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.173 +
1.174 + // Add the transitions in the order they are to run
1.175 + AddTransitionL(new(ELeave)CExampleInterfaceNewWPLTransition(*iUTContext, *iCtorValidator));
1.176 + AddTransitionL(new(ELeave)CExampleInterfaceDtorTransition(*iUTContext, *iDtorValidator));
1.177 +
1.178 + AddTransitionL(new(ELeave)CExampleInterfaceNewResolveLTransition(*iUTContext, *iCtorValidator));
1.179 + AddTransitionL(new(ELeave)CExampleInterfaceDtorTransition(*iUTContext, *iDtorValidator));
1.180 +
1.181 + }
1.182 +
1.183 +// ______________________________________________________________________________
1.184 +//
1.185 +_LIT(KExampleInterfaceListAllImplementationsUnitTest,"CExampleInterface_ListImplementations_UnitTest");
1.186 +
1.187 +CExampleInterface_ListImplementations_UnitTest* CExampleInterface_ListImplementations_UnitTest::NewL(CDataLogger& aDataLogger,
1.188 + MUnitTestObserver& aObserver)
1.189 + {
1.190 + CExampleInterface_ListImplementations_UnitTest* self =
1.191 + new(ELeave) CExampleInterface_ListImplementations_UnitTest(aDataLogger,
1.192 + aObserver);
1.193 + CleanupStack::PushL(self);
1.194 + self->ConstructL();
1.195 + CleanupStack::Pop();
1.196 + return self;
1.197 + }
1.198 +
1.199 +inline TInt CExampleInterface_ListImplementations_UnitTest::RunError(TInt aError)
1.200 + {
1.201 + // The RunL left so chain to the base first and then cleanup
1.202 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.203 + delete iUTContext;
1.204 + iUTContext = NULL;
1.205 + delete iStateAccessor;
1.206 + // delete any validators used
1.207 + delete iCtorValidator;
1.208 + iCtorValidator = NULL;
1.209 + delete iListImplementationsValidator;
1.210 + iListImplementationsValidator = NULL;
1.211 + delete iDtorValidator;
1.212 + iDtorValidator = NULL;
1.213 +
1.214 + return error;
1.215 + }
1.216 +
1.217 +inline CExampleInterface_ListImplementations_UnitTest::~CExampleInterface_ListImplementations_UnitTest()
1.218 + {
1.219 + delete iUTContext;
1.220 + delete iStateAccessor;
1.221 + // delete any validators used
1.222 + delete iCtorValidator;
1.223 + delete iListImplementationsValidator;
1.224 + delete iDtorValidator;
1.225 + }
1.226 +
1.227 +inline CExampleInterface_ListImplementations_UnitTest::CExampleInterface_ListImplementations_UnitTest(CDataLogger& aDataLogger,
1.228 + MUnitTestObserver& aObserver)
1.229 +: CUnitTest(KExampleInterfaceListAllImplementationsUnitTest, aDataLogger, aObserver)
1.230 + {
1.231 + //Do nothing
1.232 + }
1.233 +
1.234 +// Now the Individual transitions need to be added.
1.235 +inline void CExampleInterface_ListImplementations_UnitTest::ConstructL()
1.236 + {
1.237 + // Perform the base class initialization
1.238 + UnitTestConstructL();
1.239 +
1.240 + // Create the Unit test state accessor
1.241 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor;
1.242 + // Construct the Unit test context.
1.243 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.244 + // Add the Transitions in the order they are to run
1.245 + // C'tor first, D'tor last...
1.246 + // Examples of C'tor and D'tor transitions on CExampleInterface class.
1.247 + // using ctor and dtor validators
1.248 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.249 + AddTransitionL(new(ELeave)CExampleInterfaceNewLTransition(*iUTContext,*iCtorValidator));
1.250 +
1.251 + iListImplementationsValidator = new(ELeave) TExampleInterface_ListImplementations_TransitionValidator(*iUTContext);
1.252 + AddTransitionL(new(ELeave)CExampleInterfaceListAllImplementationsLTransition(*iUTContext,*iListImplementationsValidator));
1.253 + AddTransitionL(new(ELeave)CExampleInterfaceListImplementationsLTransition(*iUTContext,*iListImplementationsValidator));
1.254 +
1.255 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.256 + AddTransitionL(new(ELeave)CExampleInterfaceDtorTransition(*iUTContext,*iDtorValidator));
1.257 + }
1.258 +
1.259 +// ______________________________________________________________________________
1.260 +//
1.261 +_LIT(KExampleInterfaceDefectHAN4WZHSYUnitTest,"CExampleInterface_DefectHAN4WZHSY_UnitTest");
1.262 +
1.263 +CExampleInterface_DefectHAN4WZHSY_UnitTest* CExampleInterface_DefectHAN4WZHSY_UnitTest::NewL(CDataLogger& aDataLogger,
1.264 + MUnitTestObserver& aObserver)
1.265 + {
1.266 + CExampleInterface_DefectHAN4WZHSY_UnitTest* self =
1.267 + new(ELeave) CExampleInterface_DefectHAN4WZHSY_UnitTest(aDataLogger,
1.268 + aObserver);
1.269 + CleanupStack::PushL(self);
1.270 + self->ConstructL();
1.271 + CleanupStack::Pop();
1.272 + return self;
1.273 + }
1.274 +
1.275 +inline TInt CExampleInterface_DefectHAN4WZHSY_UnitTest::RunError(TInt aError)
1.276 + {
1.277 + // The RunL left so chain to the base first and then cleanup
1.278 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.279 + delete iUTContext;
1.280 + delete iStateAccessor;
1.281 +
1.282 + iUTContext = 0;
1.283 + iStateAccessor = 0;
1.284 +
1.285 + delete iCtorValidator;
1.286 + delete iDtorValidator;
1.287 +
1.288 + iCtorValidator = 0;
1.289 + iDtorValidator = 0;
1.290 +
1.291 + return error;
1.292 + }
1.293 +
1.294 +inline CExampleInterface_DefectHAN4WZHSY_UnitTest::~CExampleInterface_DefectHAN4WZHSY_UnitTest()
1.295 + {
1.296 + // Simply delete our test class instance
1.297 + delete iUTContext;
1.298 + delete iStateAccessor;
1.299 +
1.300 + delete iCtorValidator;
1.301 + delete iDtorValidator;
1.302 + }
1.303 +
1.304 +inline CExampleInterface_DefectHAN4WZHSY_UnitTest::CExampleInterface_DefectHAN4WZHSY_UnitTest(CDataLogger& aDataLogger,
1.305 + MUnitTestObserver& aObserver)
1.306 +: CUnitTest(KExampleInterfaceDefectHAN4WZHSYUnitTest, aDataLogger, aObserver)
1.307 + {
1.308 + //Do nothing
1.309 + }
1.310 +
1.311 +// Now the Individual transitions need to be added.
1.312 +inline void CExampleInterface_DefectHAN4WZHSY_UnitTest::ConstructL()
1.313 + {
1.314 + // Perform the base class initialization
1.315 + UnitTestConstructL();
1.316 +
1.317 + // Create the Unit test state accessor
1.318 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor;
1.319 + // Construct the Unit test context.
1.320 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.321 +
1.322 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.323 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.324 +
1.325 + AddTransitionL(new(ELeave)CExampleInterfaceNewLTransition(*iUTContext,*iCtorValidator));
1.326 + AddTransitionL(new(ELeave)CExampleInterfaceDtorTransition(*iUTContext,*iDtorValidator));
1.327 + }
1.328 +
1.329 +// ______________________________________________________________________________
1.330 +//
1.331 +_LIT(KExampleInterfaceDefectCUO4YCEUEUnitTest,"CExampleInterface_DefectCUO4YCEUE_UnitTest");
1.332 +
1.333 +CExampleInterface_DefectCUO4YCEUE_UnitTest* CExampleInterface_DefectCUO4YCEUE_UnitTest::NewL(CDataLogger& aDataLogger,
1.334 + MUnitTestObserver& aObserver)
1.335 + {
1.336 + CExampleInterface_DefectCUO4YCEUE_UnitTest* self =
1.337 + new(ELeave) CExampleInterface_DefectCUO4YCEUE_UnitTest(aDataLogger,
1.338 + aObserver);
1.339 + CleanupStack::PushL(self);
1.340 + self->ConstructL();
1.341 + CleanupStack::Pop(self);
1.342 + return self;
1.343 + }
1.344 +
1.345 +inline TInt CExampleInterface_DefectCUO4YCEUE_UnitTest::RunError(TInt aError)
1.346 + {
1.347 + // The RunL left so chain to the base first and then cleanup
1.348 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.349 + delete iUTContext;
1.350 + delete iStateAccessor;
1.351 +
1.352 + delete iCtorValidator;
1.353 + delete iDtorValidator;
1.354 +
1.355 + iUTContext = 0;
1.356 + iStateAccessor = 0;
1.357 +
1.358 + iCtorValidator = 0;
1.359 + iDtorValidator = 0;
1.360 +
1.361 + return error;
1.362 + }
1.363 +
1.364 +inline CExampleInterface_DefectCUO4YCEUE_UnitTest::~CExampleInterface_DefectCUO4YCEUE_UnitTest()
1.365 + {
1.366 + // Simply delete our test class instance
1.367 + delete iUTContext;
1.368 + delete iStateAccessor;
1.369 +
1.370 + delete iCtorValidator;
1.371 + delete iDtorValidator;
1.372 + }
1.373 +
1.374 +inline CExampleInterface_DefectCUO4YCEUE_UnitTest::CExampleInterface_DefectCUO4YCEUE_UnitTest(CDataLogger& aDataLogger,
1.375 + MUnitTestObserver& aObserver)
1.376 +: CUnitTest(KExampleInterfaceDefectCUO4YCEUEUnitTest, aDataLogger, aObserver)
1.377 + {
1.378 + //Do nothing
1.379 + }
1.380 +
1.381 +// Now the Individual transitions need to be added.
1.382 +inline void CExampleInterface_DefectCUO4YCEUE_UnitTest::ConstructL()
1.383 + {
1.384 + // Perform the base class initialization
1.385 + UnitTestConstructL();
1.386 +
1.387 + // Create the Unit test state accessor
1.388 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor;
1.389 + // Construct the Unit test context.
1.390 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.391 +
1.392 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.393 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.394 +
1.395 + AddTransitionL(new(ELeave)CExampleInterfaceDoubleNewLTransition(*iUTContext,*iCtorValidator));
1.396 + AddTransitionL(new(ELeave)CExampleInterfaceDoubleDtorTransition(*iUTContext,*iDtorValidator));
1.397 + }
1.398 +
1.399 +// ______________________________________________________________________________
1.400 +//
1.401 +_LIT(KExampleInterfaceDefectEVS4Z9BPGUnitTest,"CExampleInterface_DefectEVS4Z9BPG_UnitTest");
1.402 +
1.403 +CExampleInterface_DefectEVS4Z9BPG_UnitTest* CExampleInterface_DefectEVS4Z9BPG_UnitTest::NewL(CDataLogger& aDataLogger,
1.404 + MUnitTestObserver& aObserver)
1.405 + {
1.406 + CExampleInterface_DefectEVS4Z9BPG_UnitTest* self =
1.407 + new(ELeave) CExampleInterface_DefectEVS4Z9BPG_UnitTest(aDataLogger,
1.408 + aObserver);
1.409 + CleanupStack::PushL(self);
1.410 + self->ConstructL();
1.411 + CleanupStack::Pop(self);
1.412 + return self;
1.413 + }
1.414 +
1.415 +inline TInt CExampleInterface_DefectEVS4Z9BPG_UnitTest::RunError(TInt aError)
1.416 + {
1.417 + // The RunL left so chain to the base first and then cleanup
1.418 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.419 + delete iUTContext;
1.420 + delete iStateAccessor;
1.421 +
1.422 + delete iCtorValidator;
1.423 + delete iDefaultValidator;
1.424 + delete iDtorValidator;
1.425 +
1.426 + iUTContext = 0;
1.427 + iStateAccessor = 0;
1.428 +
1.429 + iCtorValidator = 0;
1.430 + iDefaultValidator = 0;
1.431 + iDtorValidator = 0;
1.432 +
1.433 + return error;
1.434 + }
1.435 +
1.436 +inline CExampleInterface_DefectEVS4Z9BPG_UnitTest::~CExampleInterface_DefectEVS4Z9BPG_UnitTest()
1.437 + {
1.438 + // Simply delete our test class instance
1.439 + delete iUTContext;
1.440 + delete iStateAccessor;
1.441 +
1.442 + delete iCtorValidator;
1.443 + delete iDefaultValidator;
1.444 + delete iDtorValidator;
1.445 + }
1.446 +
1.447 +inline CExampleInterface_DefectEVS4Z9BPG_UnitTest::CExampleInterface_DefectEVS4Z9BPG_UnitTest(CDataLogger& aDataLogger,
1.448 + MUnitTestObserver& aObserver)
1.449 +: CUnitTest(KExampleInterfaceDefectEVS4Z9BPGUnitTest, aDataLogger, aObserver)
1.450 + {
1.451 + //Do nothing
1.452 + }
1.453 +
1.454 +// Now the Individual transitions need to be added.
1.455 +inline void CExampleInterface_DefectEVS4Z9BPG_UnitTest::ConstructL()
1.456 + {
1.457 + // Perform the base class initialization
1.458 + UnitTestConstructL();
1.459 +
1.460 + // Create the Unit test state accessor
1.461 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor;
1.462 + // Construct the Unit test context.
1.463 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.464 +
1.465 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.466 + iDefaultValidator = new(ELeave) TExampleInterface_Default_TransitionValidator(*iUTContext);
1.467 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.468 +
1.469 + AddTransitionL(new(ELeave)CExampleInterfaceDoubleNewLTransition(*iUTContext,*iCtorValidator));
1.470 + AddTransitionL(new(ELeave)CExampleInterfaceDoMethodLTransition(*iUTContext,*iDefaultValidator));
1.471 + AddTransitionL(new(ELeave)CExampleInterfaceDoubleDtorTransition(*iUTContext,*iDtorValidator));
1.472 + }
1.473 +
1.474 +// ______________________________________________________________________________
1.475 +//
1.476 +_LIT(KExampleInterfaceDefectKRN53SL4QUnitTest,"CExampleInterface_DefectKRN53SL4Q_UnitTest");
1.477 +
1.478 +CExampleInterface_DefectKRN53SL4Q_UnitTest* CExampleInterface_DefectKRN53SL4Q_UnitTest::NewL(CDataLogger& aDataLogger,
1.479 + MUnitTestObserver& aObserver)
1.480 + {
1.481 + CExampleInterface_DefectKRN53SL4Q_UnitTest* self =
1.482 + new(ELeave) CExampleInterface_DefectKRN53SL4Q_UnitTest(aDataLogger,
1.483 + aObserver);
1.484 + CleanupStack::PushL(self);
1.485 + self->ConstructL();
1.486 + CleanupStack::Pop(self);
1.487 + return self;
1.488 + }
1.489 +
1.490 +inline TInt CExampleInterface_DefectKRN53SL4Q_UnitTest::RunError(TInt aError)
1.491 + {
1.492 + // The RunL left so chain to the base first and then cleanup
1.493 + TInt error = CUnitTest::RunError(aError); // Chain to base
1.494 + delete iUTContext;
1.495 + delete iStateAccessor;
1.496 +
1.497 + delete iCtorValidator;
1.498 + delete iDefaultValidator;
1.499 + delete iDtorValidator;
1.500 +
1.501 + iUTContext = 0;
1.502 + iStateAccessor = 0;
1.503 +
1.504 + iCtorValidator = 0;
1.505 + iDefaultValidator = 0;
1.506 + iDtorValidator = 0;
1.507 +
1.508 + return error;
1.509 + }
1.510 +
1.511 +inline CExampleInterface_DefectKRN53SL4Q_UnitTest::~CExampleInterface_DefectKRN53SL4Q_UnitTest()
1.512 + {
1.513 + // Simply delete our test class instance
1.514 + delete iUTContext;
1.515 + delete iStateAccessor;
1.516 +
1.517 + delete iCtorValidator;
1.518 + delete iDefaultValidator;
1.519 + delete iDtorValidator;
1.520 + }
1.521 +
1.522 +inline CExampleInterface_DefectKRN53SL4Q_UnitTest::CExampleInterface_DefectKRN53SL4Q_UnitTest(CDataLogger& aDataLogger,
1.523 + MUnitTestObserver& aObserver)
1.524 +: CUnitTest(KExampleInterfaceDefectKRN53SL4QUnitTest, aDataLogger, aObserver)
1.525 + {
1.526 + //Do nothing
1.527 + }
1.528 +
1.529 +TInt ThreadFunc(TAny* aTrapHandler)
1.530 + {
1.531 + User::SetTrapHandler(REINTERPRET_CAST(TCleanupTrapHandler*, aTrapHandler));
1.532 +
1.533 + RImplInfoPtrArray implementations;
1.534 + TRAPD(error, CExampleInterface::ListImplementationsL(implementations));
1.535 + UNUSED_VAR(error);
1.536 + return KErrNone;
1.537 + }
1.538 +
1.539 +// Now the Individual transitions need to be added.
1.540 +inline void CExampleInterface_DefectKRN53SL4Q_UnitTest::ConstructL()
1.541 + {
1.542 + // Perform the base class initialization
1.543 + UnitTestConstructL();
1.544 +
1.545 + // Create the Unit test state accessor
1.546 + iStateAccessor = new(ELeave) TExampleInterface_StateAccessor;
1.547 + // Construct the Unit test context.
1.548 + iUTContext = new(ELeave) CExampleInterface_UnitTestContext(iDataLogger, *iStateAccessor, *this);
1.549 +
1.550 + _LIT(KNewThreadName, "ListImpl");
1.551 + User::Leave (KErrNone != iUTContext->iListImplThread.Create(KNewThreadName(), // The name of the thread
1.552 + ThreadFunc, //CExampleInterface_UnitTestContext::ListImplementationsThreadFunction, // The function to be called when this thread resumes
1.553 + 2048, // The stacksize for this thread
1.554 + 2048, // min heap size
1.555 + 2048, // max heap size
1.556 + User::TrapHandler())); // Parameter to be passed to function
1.557 +
1.558 +
1.559 + iCtorValidator = new(ELeave) TExampleInterface_Ctor_TransitionValidator(*iUTContext);
1.560 + iDefaultValidator = new(ELeave) TExampleInterface_Default_TransitionValidator(*iUTContext);
1.561 + iDtorValidator = new(ELeave) TExampleInterface_Dtor_TransitionValidator(*iUTContext);
1.562 +
1.563 + AddTransitionL(new(ELeave)CExampleInterfaceNewLTransition(*iUTContext,*iCtorValidator));
1.564 + AddTransitionL(new(ELeave)CExampleInterfaceListImplementationsLNewThreadTransition(*iUTContext,*iDefaultValidator));
1.565 + AddBlockingTransitionL(new(ELeave)CExampleInterfaceDtorTransition(*iUTContext,*iDtorValidator));
1.566 + }
1.567 +