1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
2 // All rights reserved.
3 // This component and the accompanying materials are made available
4 // under the terms of "Eclipse Public License v1.0"
5 // which accompanies this distribution, and is available
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
8 // Initial Contributors:
9 // Nokia Corporation - initial contribution.
14 // Overload of the CTransition test that provides
15 // Heap and Handle leak testing upon a test method.
23 #ifndef __LEAKTESTTRANSITIONS_H__
24 #define __LEAKTESTTRANSITIONS_H__
26 #include <ecom/test_bed/testutilities.h>
27 #include <ecom/test_bed/transition.h>
28 #include <ecom/test_bed/testbeddefinitions.h>
30 // Constants used to specify various internal states of the CLeakTestTransition
31 const TInt KMemoryLeakTestBreakNone = -1;
32 const TInt KMemoryLeakTestFailNone = 0;
33 const TInt KMemoryLeakTestFailInit = 1;
34 /** RunError depth limit test */
35 const TInt KProbablyInfinitelyLooping = 10000;
39 Comments : Overloaded Base class from which test developers
40 can derive their own transitions for both
41 synchronous and asynchronous methods on
44 This overload checks that memory does not
45 leak when using a test method, and that
46 open handles are closed correctly.
47 It is therefore not suitable for testing methods
48 which allocate/ or deallocate memory that persists after the method has
49 completed, or which open/close handles to resources for the class
50 which remain open/closed after the method completes.
52 This base class is not really suitable for use in testing non-leaving methods.
53 (The result being that sections of the code called from within the
54 leaving method will if trapped, fail and not exercise the code fully.)
57 class CLeakTestTransition : public CTransition
61 @fn IMPORT_C CLeakTestTransition(const TDesC& aTransitionId,
62 CUnitTestContext& aUTContext,
63 TTransitionValidator& aValidator)
64 Intended Usage : Default Constructor
66 @param aTransactionId The unique id of this transition.
67 @param aUTContext The context to run this transition in
68 @param aValidator Provides Pre & Post Validation checking
70 @post First phase of two phase construction is complete
72 IMPORT_C CLeakTestTransition(const TDesC& aTransitionId,
73 CUnitTestContext& aUTContext,
74 TTransitionValidator& aValidator);
76 @fn IMPORT_C virtual void RunL()
77 Intended Usage : Override of CTransition virtual method.
78 @see CTransition::RunL() for normal CTransition behaviour.
79 This overload sets up the heap allocation to fail upon a deterministic
80 count that is incremented once for each time the RunError method fires
81 with a KErrNoMemory error.
82 Whichever method is used the second call of RunL() will complete the request
83 of the CUnitTest which called this transition by setting its status word.
84 If it has been requested that this transition is repeated then the status
85 word will be set to KTestBedRepeatTest.
88 @pre RunTransition() ensures the preconditions for this function
89 @post With iTransitionFinished == ETrue test has been completed.
90 Otherwise - Leak test has been initialized and
91 test method has been called via CTransition::RunL()
94 IMPORT_C virtual void RunL();
98 @fn IMPORT_C virtual TInt RunError(TInt aErrorCode)
99 Intended Usage : Handle the RunL leave that upsets the Active Scheduler.
100 Error Condition : @see CTransition.
102 @param anErrorCode The error code that was returned by the Leave;
103 @return TInt KErrNone
104 @pre CLeakTestTransition has been fully constructed, and initialized and
105 RunL left with an error code.
106 @post CLeakTestTransition is returned to a sensible state and the test is
107 resceduled if aErrorCode was KErrNoMemory.
110 IMPORT_C virtual TInt RunError(TInt aErrorCode);
113 @fn PostTransitionCleanup()
114 Intended Usage : Called from the RunL immediately after TransitMethodL() executes
116 @pre Must be called from RunL only after TransitMethodL() has completed.
117 @post Heap failure is immediately disabled.
120 IMPORT_C virtual void PostTransitionCleanup();
122 /** The count of process open handles at the start of the RunL. */
124 TInt iStartProcessHandleCount;
125 /** The count of thread open handles at the start of the RunL. */
127 TInt iStartThreadHandleCount;
128 /** The count of process open handles at the end of the RunL/RunError. */
130 TInt iEndProcessHandleCount;
131 /** The count of thread open handles at the end of the RunL/RunError. */
133 TInt iEndThreadHandleCount;
134 /** The current thread handle */
138 /** The current iteration of the test method upon which to fail. */
141 /** The iteration of the test method upon which an unexpected failure occurred. */
146 #endif // __LEAKTESTTRANSITIONS_H__