1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Test_Bed/test_bed/UnitTest.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,336 @@
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 +// Implementation of the CUnitTest base class.
1.18 +//
1.19 +//
1.20 +
1.21 +#include <ecom/test_bed/unittest.h>
1.22 +#include <ecom/test_bed/transition.h>
1.23 +#include <ecom/test_bed/datalogger.h>
1.24 +#include <ecom/test_bed/testbeddefinitions.h>
1.25 +
1.26 +
1.27 +EXPORT_C CUnitTest::~CUnitTest()
1.28 + {
1.29 + Cancel();
1.30 +
1.31 + // Delete any outstanding asynchronous transitions
1.32 + if(iOutstandingTransitions)
1.33 + {
1.34 + iOutstandingTransitions->Reset();
1.35 + delete iOutstandingTransitions;
1.36 + }
1.37 +
1.38 + if(iTransitions)
1.39 + {
1.40 + iTransitions->ResetAndDestroy();
1.41 + delete iTransitions;
1.42 + }
1.43 +
1.44 + iLeaveErrorArray.Reset();
1.45 +
1.46 + delete iFileMan;
1.47 + iFs.Close();
1.48 + }
1.49 +
1.50 +EXPORT_C void CUnitTest::UnitTestConstructL()
1.51 + {
1.52 + User::LeaveIfError(iFs.Connect());
1.53 + iFileMan = CFileMan::NewL(iFs);
1.54 + CTimer::ConstructL();
1.55 + iTransitions = new(ELeave) RPointerArray<CTransition>;
1.56 + iOutstandingTransitions = new(ELeave) RPointerArray<CTransition>;
1.57 + _LIT(KConstructingUnitTestMsg, "Constructed Unit Test named %S");
1.58 + iDataLogger.LogInformationWithParameters(KConstructingUnitTestMsg, &iUnitTestName);
1.59 + }
1.60 +
1.61 +
1.62 +CUnitTestInfo* CUnitTest::TransitionSetL() const
1.63 + {
1.64 + CUnitTestInfo* transitionSet = CUnitTestInfo::NewL(iUnitTestName);
1.65 + return transitionSet;
1.66 + }
1.67 +
1.68 +
1.69 +EXPORT_C void CUnitTest::RunTest(TTimeIntervalMicroSeconds32 aTimeAfter /*= 0*/)
1.70 + {
1.71 + After(aTimeAfter);
1.72 + _LIT(KTxtSeparator, "-----------------------------------------------------------------------------------");
1.73 + _LIT(KStartingUnitTest, "Beginning Unit Test named %S");
1.74 + iDataLogger.LogInformation(KTxtSeparator);
1.75 + iDataLogger.LogInformationWithParameters(KStartingUnitTest, &iUnitTestName);
1.76 + iDataLogger.ReportInformationWithParameters(KStartingUnitTest, &iUnitTestName);
1.77 + }
1.78 +
1.79 +EXPORT_C void CUnitTest::RunL()
1.80 + {
1.81 + _LIT(KUnitTestRunLPanic, "CUnitTest::RunL");
1.82 +
1.83 + TInt status = iStatus.Int();
1.84 + switch(status)
1.85 + {
1.86 + case (KTestBedRepeatTest): /* A stub has requested repeat of the last test */
1.87 + // Go back one so that we repeat the last test
1.88 + --iNextTransitionIndex;
1.89 + break;
1.90 +
1.91 + case (KTestBedTestLeft): /* The last transition's RunL left */
1.92 + case (KTestBedTestCancel): /* The last transition was cancelled */
1.93 + case (KTestBedLeakTestLoopDetected): /* A leak test detected an infinite loop */
1.94 + case (KTestBedFailedPreConditions): /* The last transition failed it's pre conditions */
1.95 + case (KTestBedFailedPostConditions): /* The last transition failed it's post conditions */
1.96 + // Go to the end of the test so that it finishes
1.97 + iNextTransitionIndex = iTransitions->Count();
1.98 + break;
1.99 +
1.100 + case (KTestBedAsynchronousTransition): /* The last transition started an async request */
1.101 + // Remember that we have an outstanding request and then carry on
1.102 + iOutstandingTransitions->Append((*iTransitions)[iNextTransitionIndex - 1]);
1.103 + break;
1.104 +
1.105 + case (KErrNone):
1.106 + break;
1.107 +
1.108 + default:
1.109 + User::Panic(KUnitTestRunLPanic, KTestBedInvalidStatus);
1.110 + }
1.111 +
1.112 + // If we still have more transitions to run
1.113 + if(iNextTransitionIndex < iTransitions->Count())
1.114 + {
1.115 + iStatus = KRequestPending;
1.116 + SetActive();
1.117 +
1.118 + // If the next transition is a blocking one then wait for all outstanding async
1.119 + // requests to complete. Otherwise just run the next transition
1.120 + if(((*iTransitions)[iNextTransitionIndex]->IsBlockingTransition()) &&
1.121 + (iOutstandingTransitions->Count() > 0))
1.122 + {
1.123 + iWaitingForCompletion = ETrue;
1.124 + }
1.125 + else
1.126 + {
1.127 + (*iTransitions)[iNextTransitionIndex]->RunTransition(&iStatus);
1.128 + ++iNextTransitionIndex;
1.129 + }
1.130 + }
1.131 + else
1.132 + {
1.133 + // If we still have outstanding async requests then wait for these to complete
1.134 + // otherwise we have finished this test
1.135 + if(iOutstandingTransitions->Count() > 0)
1.136 + {
1.137 + iWaitingForCompletion = ETrue;
1.138 + iStatus = KRequestPending;
1.139 + SetActive();
1.140 + }
1.141 + else
1.142 + {
1.143 + iUnitTestObserver.Complete(this);
1.144 +
1.145 + _LIT(KInfoPrintFailed, "Failed: Unit Test");
1.146 + _LIT(KTestLeft, "Failed: Unit Test %S left");
1.147 + _LIT(KTestLeftWithUnexpectedError, "Failed: Test %S left with unexpected error");
1.148 + _LIT(KTestFailed, "Failed: Unit Test %S failed a pre/post condition validation check");
1.149 + _LIT(KTestLeftWithExpectedError, "Test %S left with an anticipated error");
1.150 + _LIT(KTestCancelled, "Cancelled: Unit Test Transition %S was cancelled");
1.151 + _LIT(KTestEnteredInfiniteLoop, "Unit Test Transition %S aborted (infinitely looping)");
1.152 + _LIT(KEndingUnitTest, "Successfully completed Unit Test %S");
1.153 + // We use RTest if it is present in the framework to validate
1.154 + // status codes for errors. Note: not all non KErrNone code mean
1.155 + // there was an error and so we need to selective over which
1.156 + // cases below we use RTest().
1.157 + switch(status)
1.158 + {
1.159 + case (KTestBedTestLeft):
1.160 + {
1.161 + TInt leaveCode = iCurrentlyExecutingTransition->GetErrorCode();
1.162 + //Check to see if the leave code is NOT on the list of known leaving codes
1.163 + if(iLeaveErrorArray.Find(leaveCode) == KErrNotFound)
1.164 + {
1.165 + iDataLogger.LogInformationWithParameters(KTestLeft, &iUnitTestName);
1.166 + iDataLogger.ReportInformationWithParameters(KTestLeft, &iUnitTestName);
1.167 + if(iRTest)
1.168 + {
1.169 + (*iRTest)(status==KErrNone);
1.170 + }
1.171 + }
1.172 + else //Leave code is on the list
1.173 + {
1.174 + TInt count = iTransitions->Count();
1.175 + //Check transition number and if it is the last transition then this is an expected error
1.176 + CTransition* lastTransition = (*iTransitions)[count-1];
1.177 + if(iCurrentlyExecutingTransition == lastTransition)
1.178 + {
1.179 + iDataLogger.LogInformationWithParameters(KTestLeftWithExpectedError, &iUnitTestName);
1.180 + iDataLogger.ReportInformationWithParameters(KEndingUnitTest, &iUnitTestName);
1.181 + }
1.182 + else //Otherwise, if not the last transition, the test failed with an unexpected error
1.183 + {
1.184 + User::InfoPrint(KInfoPrintFailed);
1.185 + User::InfoPrint(iUnitTestName);
1.186 + iDataLogger.LogInformationWithParameters(KTestLeftWithUnexpectedError, &iUnitTestName);
1.187 + iDataLogger.ReportInformationWithParameters(KTestLeftWithUnexpectedError, &iUnitTestName);
1.188 + if(iRTest)
1.189 + {
1.190 + (*iRTest)(status==KErrNone);
1.191 + }
1.192 + }
1.193 + }
1.194 + }
1.195 + break;
1.196 +
1.197 + case (KTestBedFailedPreConditions):
1.198 + case (KTestBedFailedPostConditions):
1.199 + {
1.200 + User::InfoPrint(KInfoPrintFailed);
1.201 + User::InfoPrint(iUnitTestName);
1.202 + iDataLogger.LogInformationWithParameters(KTestFailed, &iUnitTestName);
1.203 + iDataLogger.ReportInformationWithParameters(KTestFailed, &iUnitTestName);
1.204 + if(iRTest)
1.205 + {
1.206 + (*iRTest)(status==KErrNone);
1.207 + }
1.208 + }
1.209 + break;
1.210 +
1.211 + case (KTestBedTestCancel):
1.212 + iDataLogger.LogInformationWithParameters(KTestCancelled, &iUnitTestName);
1.213 + iDataLogger.ReportInformationWithParameters(KTestCancelled, &iUnitTestName);
1.214 + if(iRTest)
1.215 + {
1.216 + (*iRTest)(status==KErrNone);
1.217 + }
1.218 + break;
1.219 +
1.220 + case (KTestBedLeakTestLoopDetected):
1.221 + iDataLogger.LogInformationWithParameters(KTestEnteredInfiniteLoop, &iUnitTestName);
1.222 + iDataLogger.ReportInformationWithParameters(KTestEnteredInfiniteLoop, &iUnitTestName);
1.223 + if(iRTest)
1.224 + {
1.225 + (*iRTest)(status==KErrNone);
1.226 + }
1.227 + break;
1.228 +
1.229 + case (KErrNone):
1.230 + iDataLogger.LogInformationWithParameters(KEndingUnitTest, &iUnitTestName);
1.231 + iDataLogger.ReportInformationWithParameters(KEndingUnitTest, &iUnitTestName);
1.232 + break;
1.233 +
1.234 + default:
1.235 + User::Panic(KUnitTestRunLPanic, KTestBedInvalidStatus);
1.236 + }
1.237 + }
1.238 + }
1.239 + }
1.240 +
1.241 +EXPORT_C void CUnitTest::AddTransitionL(CTransition* aTransition)
1.242 + {
1.243 + __ASSERT_DEBUG(aTransition, User::Panic(_L("CUnitTest"), KErrTestBedInvalidTransition));
1.244 + CleanupStack::PushL(aTransition);
1.245 + User::LeaveIfError(iTransitions->Append(aTransition));
1.246 + CleanupStack::Pop(aTransition);
1.247 + }
1.248 +
1.249 +EXPORT_C void CUnitTest::AddBlockingTransitionL(CTransition* aTransition)
1.250 + {
1.251 + __ASSERT_DEBUG(aTransition, User::Panic(_L("CUnitTest"), KErrTestBedInvalidTransition));
1.252 + aTransition->SetBlockingTransition(ETrue);
1.253 + CleanupStack::PushL(aTransition);
1.254 + User::LeaveIfError(iTransitions->Append(aTransition));
1.255 + CleanupStack::Pop(aTransition);
1.256 + }
1.257 +
1.258 +EXPORT_C void CUnitTest::AddLeaveErrorCodeL(TInt aLeaveErrorCode)
1.259 + {
1.260 + User::LeaveIfError(iLeaveErrorArray.Append(aLeaveErrorCode));
1.261 + }
1.262 +
1.263 +EXPORT_C CTransition& CUnitTest::GetCurrentTransition() const
1.264 + {
1.265 + // Check fror a stray stub call
1.266 + // We will always have a valid pointer here IF called
1.267 + // from a stub in response to that transition's call
1.268 + // on the stub's methods.
1.269 + __ASSERT_DEBUG(iCurrentlyExecutingTransition, User::Invariant());
1.270 + return *iCurrentlyExecutingTransition;
1.271 + }
1.272 +
1.273 +EXPORT_C void CUnitTest::SetCurrentTransition(CTransition& aTransition)
1.274 + {
1.275 + iCurrentlyExecutingTransition = &aTransition;
1.276 + }
1.277 +
1.278 +EXPORT_C void CUnitTest::Complete(CTransition& aTransition, TInt aAsyncPostCheckError)
1.279 + {
1.280 + // Should never be NULL at this point
1.281 + __ASSERT_DEBUG(iCurrentlyExecutingTransition, User::Invariant());
1.282 + if(iCurrentlyExecutingTransition == &aTransition)
1.283 + iCurrentlyExecutingTransition = NULL; // Clear the current transition
1.284 +
1.285 + // Oops the code will crash if this is ever false
1.286 + __ASSERT_DEBUG(iOutstandingTransitions, User::Invariant());
1.287 +
1.288 + // Look-up the transition passed in...
1.289 + TInt index = iOutstandingTransitions->Find(&aTransition);
1.290 + if(index != KErrNotFound)
1.291 + {
1.292 + // ... and remove from the set of outstanding ones.
1.293 + iOutstandingTransitions->Remove(index);
1.294 +
1.295 + // Did we fail a second-phase post-condition validation on an asynchronous transition?
1.296 + // Or was it a normal transition completion? Regardless, we go for another iteration
1.297 + // of the AO, passing through the error code.
1.298 + TBool completeIt = (aAsyncPostCheckError != KErrNone);
1.299 + if(iWaitingForCompletion && (iOutstandingTransitions->Count() == 0))
1.300 + completeIt = ETrue;
1.301 +
1.302 + if (completeIt)
1.303 + {
1.304 + TRequestStatus* status = &iStatus;
1.305 + User::RequestComplete(status, aAsyncPostCheckError);
1.306 + }
1.307 + }
1.308 + else
1.309 + {
1.310 + __ASSERT_DEBUG(ETrue,
1.311 + User::Panic(_L("CUnitTest"), KErrTestBedInvalidTransition));
1.312 + }
1.313 + }
1.314 +
1.315 +EXPORT_C void CUnitTest::SetParametersL(TAny* /*aParams*/)
1.316 + {
1.317 + // Do nothing
1.318 + }
1.319 +
1.320 +EXPORT_C void CUnitTest::DoCancel()
1.321 + {
1.322 + CTimer::DoCancel();
1.323 +
1.324 + if(iCurrentlyExecutingTransition)
1.325 + iCurrentlyExecutingTransition->Cancel();
1.326 +
1.327 + // Cancel any outstanding asynchronous transitions
1.328 + if(iOutstandingTransitions)
1.329 + {
1.330 + TInt count = iOutstandingTransitions->Count();
1.331 + for(TInt index = 0; index < count; ++index)
1.332 + {
1.333 + (*iOutstandingTransitions)[index]->Cancel();
1.334 + }
1.335 + }
1.336 +
1.337 + iUnitTestObserver.Complete(this);
1.338 + }
1.339 +