os/ossrv/lowlevellibsandfws/pluginfw/Framework/BackupNotifierTest/t_BackUpNotifier.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/BackupNotifierTest/t_BackUpNotifier.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,554 @@
1.4 +// Copyright (c) 2004-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 test classes and their implementations
1.18 +// to test production class CBackupNotifier. Where necessary stubs
1.19 +// are implemented to help in writing test harness using RTest.
1.20 +//
1.21 +//
1.22 +
1.23 +#include <e32test.h>
1.24 +#include <s32file.h>
1.25 +#include <bautils.h>
1.26 +
1.27 +#include "BackupNotifier.h"
1.28 +#include "BackupNotifierObserver.h"
1.29 +
1.30 +// Used for suppressing warning in OOM tests
1.31 +#define __UNUSED_VAR(var) var = var
1.32 +
1.33 +LOCAL_D CTrapCleanup* TheTrapCleanup =NULL;
1.34 +
1.35 +LOCAL_D CActiveScheduler* TheActiveScheduler =NULL;
1.36 +
1.37 +LOCAL_D RTest test(_L("t_backupnotifier.exe"));
1.38 +
1.39 +//It is used by some test methods which are called two times:
1.40 +//from normal test and from OOM test.
1.41 +static void LeaveIfErrNoMemory(TInt aError)
1.42 + {
1.43 + if(aError == KErrNoMemory)
1.44 + {
1.45 + User::Leave(aError);
1.46 + }
1.47 + }
1.48 +
1.49 +/**
1.50 +Stub classes are provided to act as replacement members for the class
1.51 +under test. This ensures the test class is constructed correctly and its
1.52 +behaviour is also correct within the context of the test. It allows the
1.53 +class to be tested in isolation. Other tests are available that test the
1.54 +interoperability of the class
1.55 +*/
1.56 +class CBackupNotifierObserverStub : public CBase, public MBackupNotifierObserver
1.57 + {
1.58 +public:
1.59 +
1.60 + CBackupNotifierObserverStub();
1.61 + ~CBackupNotifierObserverStub();
1.62 + TInt Suspend();
1.63 + TInt Resume();
1.64 +
1.65 + /** Flag to check for BackupNotifierObserver directory scanning status*/
1.66 + TBool iSuspended;
1.67 + };
1.68 +
1.69 +CBackupNotifierObserverStub::CBackupNotifierObserverStub()
1.70 +: CBase()
1.71 + {
1.72 + iSuspended = EFalse;
1.73 + }
1.74 +
1.75 +CBackupNotifierObserverStub::~CBackupNotifierObserverStub()
1.76 + {
1.77 + // Do nothing here
1.78 + }
1.79 +
1.80 +/**
1.81 +Overload of the MBackupNotifierObserver method.
1.82 +Called to stop the directory scanning as the backup session is started.
1.83 +*/
1.84 +TInt CBackupNotifierObserverStub::Suspend()
1.85 + {
1.86 + iSuspended = ETrue;
1.87 + return KErrNone;
1.88 + }
1.89 +
1.90 +
1.91 +/**
1.92 +Overload of the MBackupNotifierObserver method.
1.93 +Called to resume the directory scanning as the backup session is over.
1.94 +*/
1.95 +TInt CBackupNotifierObserverStub::Resume()
1.96 + {
1.97 + iSuspended = EFalse;
1.98 + return KErrNone;
1.99 + }
1.100 +
1.101 +/**
1.102 +This friend class allows us to access private and protected members of production
1.103 +code class BackupNotifier.
1.104 +*/
1.105 +class TBackupNotifier_StateAccessor
1.106 +{
1.107 +public:
1.108 + void HandleBackupOperationEventL(CBackupNotifier& , const TBackupOperationAttributes&);
1.109 + void RegisterForNotificationsL(CBackupNotifier& aNotifier);
1.110 + void DeregisterForNotifications(CBackupNotifier& aNotifier);
1.111 + TBool IsRegisteredForNotifications(CBackupNotifier& aNotifier);
1.112 +};
1.113 +
1.114 +/**
1.115 +Handles the Backup operation event.
1.116 +
1.117 +@param aNotifier The CBackupNotifier class object under test
1.118 +@param aAttributes Attribute specifying the Backup event(Start/Stop)
1.119 +*/
1.120 +void TBackupNotifier_StateAccessor::HandleBackupOperationEventL(CBackupNotifier& aNotifier,
1.121 + const TBackupOperationAttributes& aAttributes)
1.122 + {
1.123 + aNotifier.HandleBackupOperationEventL(aAttributes);
1.124 + }
1.125 +
1.126 +/**
1.127 +Creates the Backup session if already not created and Registers BackupNotifier for
1.128 +notifications from the backup server.
1.129 +
1.130 +@param aNotifier The CBackupNotifier class object under test
1.131 +*/
1.132 +void TBackupNotifier_StateAccessor::RegisterForNotificationsL(CBackupNotifier& aNotifier)
1.133 + {
1.134 + aNotifier.RegisterForNotificationsL();
1.135 + }
1.136 +
1.137 +/**
1.138 +Deregisters the BackupNotifier for notifications from the backup server and deletes
1.139 +the Backup session object.
1.140 +
1.141 +@param aNotifier The CBackupNotifier class object under test
1.142 +*/
1.143 +void TBackupNotifier_StateAccessor::DeregisterForNotifications(CBackupNotifier& aNotifier)
1.144 + {
1.145 + if(aNotifier.iBackupSession)
1.146 + {
1.147 + if(aNotifier.iIsRegistered)
1.148 + {
1.149 + aNotifier.iBackupSession->DeRegisterBackupOperationObserver(aNotifier);
1.150 + }
1.151 + delete aNotifier.iBackupSession;
1.152 + aNotifier.iBackupSession = NULL;
1.153 + }
1.154 + aNotifier.iIsRegistered = EFalse;
1.155 + }
1.156 +
1.157 +/**
1.158 +Checks whether the notifier object is registered for backup notifications.
1.159 +
1.160 +@param aNotifier The CBackupNotifier class object under test
1.161 +*/
1.162 +TBool TBackupNotifier_StateAccessor::IsRegisteredForNotifications(CBackupNotifier& aNotifier)
1.163 + {
1.164 + return aNotifier.iIsRegistered;
1.165 + }
1.166 +
1.167 +
1.168 +/**
1.169 +Test class encloses necessary members that aid to test CBackupNotifier
1.170 +*/
1.171 +class CBackUpNotifierTest: public CBase
1.172 + {
1.173 +public:
1.174 + static CBackUpNotifierTest* NewL();
1.175 +
1.176 + ~CBackUpNotifierTest();
1.177 + void HandleBackupOperationEventTestL();
1.178 + void RegisterForNotificationsTestL();
1.179 +
1.180 +private:
1.181 + CBackUpNotifierTest();
1.182 + void ConstructL();
1.183 +
1.184 +public:
1.185 + /** The instance of the class under test */
1.186 + CBackupNotifier* iBackupNotifier;
1.187 +
1.188 + /** The instance of the stubbed observer of the class under test */
1.189 + CBackupNotifierObserverStub* iObserverStub;
1.190 +
1.191 + /** Friend class pointer used for accessing private members */
1.192 + TBackupNotifier_StateAccessor* iStateAccessor;
1.193 + };
1.194 +
1.195 +/**
1.196 +Create a new CBackUpNotifierTest object
1.197 +@return A pointer to the newly created class.
1.198 +*/
1.199 +CBackUpNotifierTest* CBackUpNotifierTest::NewL()
1.200 + {
1.201 + CBackUpNotifierTest* self = new (ELeave) CBackUpNotifierTest();
1.202 + CleanupStack::PushL(self);
1.203 + self->ConstructL();
1.204 + CleanupStack::Pop();
1.205 + return self;
1.206 + }
1.207 +
1.208 +/**
1.209 +Standardized default constructor
1.210 +@post CBackUpNotifierTest is fully constructed
1.211 +*/
1.212 +
1.213 +CBackUpNotifierTest::CBackUpNotifierTest()
1.214 + {
1.215 + // Do nothing here
1.216 + }
1.217 +
1.218 +/**
1.219 +Standardized 2nd(Initialization) phase of two phase construction.
1.220 +Completes the safe construction of the CBackUpNotifierTest object
1.221 +@post CBackUpNotifierTest is fully constructed.
1.222 +@leave KErrNoMemory.
1.223 +*/
1.224 +void CBackUpNotifierTest::ConstructL()
1.225 + {
1.226 + iStateAccessor = new(ELeave) TBackupNotifier_StateAccessor();
1.227 + iObserverStub = new(ELeave) CBackupNotifierObserverStub();
1.228 + iBackupNotifier = CBackupNotifier::NewL(*iObserverStub);
1.229 + }
1.230 +
1.231 +/**
1.232 +Standard destructor
1.233 +*/
1.234 +CBackUpNotifierTest::~CBackUpNotifierTest()
1.235 + {
1.236 + delete iBackupNotifier;
1.237 + delete iObserverStub;
1.238 + delete iStateAccessor;
1.239 + }
1.240 +
1.241 +/**
1.242 +The test executes by first starting the backup session and then by ending it.
1.243 +Backup operation event notifications are passed to the observer(i.e CRegistrar) for
1.244 +notifing CDiscoverer to start/ stop the discoveries process depending on the
1.245 +event(Backup start/end). The observer stub class is being used for the
1.246 +verification of the results.
1.247 +
1.248 +@SYMTestCaseID SYSLIB-ECOM-CT-0753
1.249 +@SYMTestCaseDesc Tests for CBackupNotifier::HandleBackupOperationEventL function
1.250 +@SYMTestPriority High
1.251 +@SYMTestActions Setting the backup operation attributes before starting the backup operation.
1.252 + Suspend BackupNotifier observer.
1.253 + Reset backup operation attributes and stop the backup operation.
1.254 + Resume BackupNotifier observer.
1.255 +@SYMTestExpectedResults The test must not fail.
1.256 +@SYMREQ REQ0000
1.257 +*/
1.258 +void CBackUpNotifierTest::HandleBackupOperationEventTestL()
1.259 + {
1.260 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0753 "));
1.261 + TBackupOperationAttributes attribs;
1.262 + // Setting the backup operation attributes before making the event.
1.263 + attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;
1.264 + attribs.iOperation=MBackupOperationObserver::EStart;
1.265 +
1.266 + // Start the backup operation
1.267 + TRAPD(err, iStateAccessor->HandleBackupOperationEventL(*iBackupNotifier, attribs));
1.268 + ::LeaveIfErrNoMemory(err);
1.269 + test(err == KErrNone);
1.270 + // BackupNotifier observer should get suspended. The directory scanning process(in stub class)
1.271 + // should get stopped as backup is started.
1.272 + test(iObserverStub->iSuspended);
1.273 +
1.274 + // Resetting the backup operation attributes before making another event.
1.275 + attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;
1.276 + attribs.iOperation=MBackupOperationObserver::EEnd;
1.277 +
1.278 + // Stop the backup operation
1.279 + TRAP(err, iStateAccessor->HandleBackupOperationEventL(*iBackupNotifier, attribs));
1.280 + ::LeaveIfErrNoMemory(err);
1.281 + test(err == KErrNone);
1.282 + // BackupNotifier observer should get resumed. The directory scanning process(in stub class)
1.283 + // should get resumed as backup is over.
1.284 + test(!iObserverStub->iSuspended);
1.285 + }
1.286 +
1.287 +/**
1.288 +@SYMTestCaseID SYSLIB-ECOM-CT-0754
1.289 +@SYMTestCaseDesc Register for notification test
1.290 +@SYMTestPriority High
1.291 +@SYMTestActions Tests by first unregistring(if already registerd) the Backup notifier for notifications
1.292 + and then by registering for notifications from the backup server.
1.293 +@SYMTestExpectedResults The test must not fail.
1.294 +@SYMREQ REQ0000
1.295 +*/
1.296 +void CBackUpNotifierTest::RegisterForNotificationsTestL()
1.297 + {
1.298 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0754 "));
1.299 + TBool isRegistered = iStateAccessor->IsRegisteredForNotifications(*iBackupNotifier);
1.300 +
1.301 + // Idealy it should got registered when the CBackupNotifier object is created.
1.302 + if(isRegistered)
1.303 + {
1.304 + TRAPD(err, iStateAccessor->DeregisterForNotifications(*iBackupNotifier));
1.305 + ::LeaveIfErrNoMemory(err);
1.306 + test(err == KErrNone);
1.307 + }
1.308 +
1.309 + // Backup notifier should not be registerd for backup operation events.
1.310 + isRegistered = iStateAccessor->IsRegisteredForNotifications(*iBackupNotifier);
1.311 + test(!isRegistered);
1.312 +
1.313 + // Register the Backup Notifier for the backup operation events.
1.314 + TRAPD(err, iStateAccessor->RegisterForNotificationsL(*iBackupNotifier));
1.315 + ::LeaveIfErrNoMemory(err);
1.316 + test(err == KErrNone);
1.317 +
1.318 + // Backup notifier should be registerd for backup operation events.
1.319 + isRegistered = iStateAccessor->IsRegisteredForNotifications(*iBackupNotifier);
1.320 + test(isRegistered);
1.321 + }
1.322 +
1.323 +/**
1.324 +@SYMTestCaseID SYSLIB-ECOM-CT-0755
1.325 +@SYMTestCaseDesc Create and delete test of CBackUpNotifier
1.326 +@SYMTestPriority High
1.327 +@SYMTestActions Check for handle leak after deletion of object.
1.328 +@SYMTestExpectedResults The test must not fail.
1.329 +@SYMREQ REQ0000
1.330 +*/
1.331 +LOCAL_C void CreateDeleteTestL()
1.332 + {
1.333 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0755 CreateDeleteTestL "));
1.334 + // Set up for heap leak checking
1.335 + __UHEAP_MARK;
1.336 +
1.337 + // and leaking thread handles
1.338 + TInt startProcessHandleCount;
1.339 + TInt startThreadHandleCount;
1.340 + TInt endProcessHandleCount;
1.341 + TInt endThreadHandleCount;
1.342 +
1.343 + // Test Starts...
1.344 + RThread thisThread;
1.345 + thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount);
1.346 +
1.347 + CBackUpNotifierTest* notifierTest = CBackUpNotifierTest::NewL();
1.348 +
1.349 + test(notifierTest!=NULL);
1.350 +
1.351 + delete notifierTest;
1.352 +
1.353 + // Check for open handles
1.354 + thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount);
1.355 + test(startThreadHandleCount == endThreadHandleCount);
1.356 +
1.357 + __UHEAP_MARKEND;
1.358 + }
1.359 +
1.360 +/**
1.361 +@SYMTestCaseID SYSLIB-ECOM-CT-0756
1.362 +@SYMTestCaseDesc OOM Test for create and delete of CBackUpNotifier
1.363 +@SYMTestPriority High
1.364 +@SYMTestActions Check for handle leak after deletion of object.
1.365 +@SYMTestExpectedResults The test must not fail.
1.366 +@SYMREQ REQ0000
1.367 +*/
1.368 +LOCAL_C void OOMCreateDeleteTest()
1.369 + {
1.370 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0756 OOM CreateDeleteTest "));
1.371 + TInt err;
1.372 + TInt failAt = 1;
1.373 + __UNUSED_VAR(failAt);
1.374 +
1.375 + CBackUpNotifierTest* theTest = NULL;
1.376 +
1.377 + do
1.378 + {
1.379 + __UHEAP_MARK;
1.380 + // find out the number of open handles
1.381 + TInt startProcessHandleCount;
1.382 + TInt startThreadHandleCount;
1.383 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.384 +
1.385 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.386 +
1.387 + TRAP(err, theTest = CBackUpNotifierTest::NewL());
1.388 +
1.389 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.390 +
1.391 + delete theTest;
1.392 + theTest = NULL;
1.393 +
1.394 + // check that no handles have leaked
1.395 + TInt endProcessHandleCount;
1.396 + TInt endThreadHandleCount;
1.397 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.398 +
1.399 + test(startProcessHandleCount == endProcessHandleCount);
1.400 + test(startThreadHandleCount == endThreadHandleCount);
1.401 +
1.402 + __UHEAP_MARKEND;
1.403 + }
1.404 + while(err == KErrNoMemory);
1.405 +
1.406 + test.Printf(_L("- Succeeded at heap failure rate of %i\n"), failAt);
1.407 + test(err == KErrNone);
1.408 + }
1.409 +
1.410 +// Type definition for pointer to member function.
1.411 +// Used in calling the CBackUpNotifierTest member function for testing.
1.412 +typedef void (CBackUpNotifierTest::*ClassFuncPtrL) (void);
1.413 +
1.414 +/**
1.415 +@SYMTestCaseID SYSLIB-ECOM-CT-0757
1.416 +@SYMTestCaseDesc Function to call all test functions
1.417 +@SYMTestPriority High
1.418 +@SYMTestActions Calls up test functions of CBackupNotifier,check that no handles have leaked
1.419 +@SYMTestExpectedResults The test must not fail.
1.420 +@SYMREQ REQ0000
1.421 +*/
1.422 +/**
1.423 +Wrapper function to call all test functions
1.424 +@param testFunc pointer to test function
1.425 +@param aTestDesc test function name
1.426 +*/
1.427 +LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
1.428 + {
1.429 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0757 "));
1.430 + test.Next(aTestDesc);
1.431 +
1.432 + __UHEAP_MARK;
1.433 + // find out the number of open handles
1.434 + TInt startProcessHandleCount;
1.435 + TInt startThreadHandleCount;
1.436 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.437 +
1.438 + CBackUpNotifierTest* theTest = CBackUpNotifierTest::NewL();
1.439 + CleanupStack::PushL(theTest);
1.440 +
1.441 + (theTest->*testFuncL)();
1.442 +
1.443 + CleanupStack::PopAndDestroy(theTest);
1.444 +
1.445 + // check that no handles have leaked
1.446 + TInt endProcessHandleCount;
1.447 + TInt endThreadHandleCount;
1.448 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.449 +
1.450 + test(startProcessHandleCount == endProcessHandleCount);
1.451 + test(startThreadHandleCount == endThreadHandleCount);
1.452 +
1.453 + __UHEAP_MARKEND;
1.454 + }
1.455 +
1.456 +/**
1.457 +@SYMTestCaseID SYSLIB-ECOM-CT-0758
1.458 +@SYMTestCaseDesc Function to call all OOM test functions
1.459 +@SYMTestPriority High
1.460 +@SYMTestActions Calls up all OOM test function related to CBackupNotifier
1.461 +@SYMTestExpectedResults The test must not fail.
1.462 +@SYMREQ REQ0000
1.463 +*/
1.464 +/**
1.465 +Wrapper function to call all OOM test functions
1.466 +@param testFuncL pointer to OOM test function
1.467 +@param aTestDesc test function name
1.468 +*/
1.469 +LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
1.470 + {
1.471 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0758 "));
1.472 + test.Next(aTestDesc);
1.473 +
1.474 + TInt err;
1.475 + TInt tryCount = 0;
1.476 + do
1.477 + {
1.478 + __UHEAP_MARK;
1.479 + // find out the number of open handles
1.480 + TInt startProcessHandleCount;
1.481 + TInt startThreadHandleCount;
1.482 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.483 +
1.484 + CBackUpNotifierTest* theTest = CBackUpNotifierTest::NewL();
1.485 + CleanupStack::PushL(theTest);
1.486 +
1.487 + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
1.488 +
1.489 + TRAP(err, (theTest->*testFuncL)());
1.490 +
1.491 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.492 +
1.493 + CleanupStack::PopAndDestroy(theTest);
1.494 + theTest = NULL;
1.495 + // check that no handles have leaked
1.496 + TInt endProcessHandleCount;
1.497 + TInt endThreadHandleCount;
1.498 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.499 +
1.500 + test(startProcessHandleCount == endProcessHandleCount);
1.501 + test(startThreadHandleCount == endThreadHandleCount);
1.502 +
1.503 + __UHEAP_MARKEND;
1.504 + } while(err == KErrNoMemory);
1.505 +
1.506 + test(err == KErrNone);
1.507 + test.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
1.508 + }
1.509 +
1.510 +LOCAL_C void DoTestsL()
1.511 + {
1.512 + __UHEAP_MARK;
1.513 +
1.514 + CreateDeleteTestL();
1.515 + DoBasicTestL(&CBackUpNotifierTest::HandleBackupOperationEventTestL, _L("HandleBackupOperationEventL Test"));
1.516 + DoBasicTestL(&CBackUpNotifierTest::RegisterForNotificationsTestL, _L("RegisterForNotificationsL Test"));
1.517 +
1.518 + OOMCreateDeleteTest();
1.519 + DoOOMTestL(&CBackUpNotifierTest::HandleBackupOperationEventTestL, _L("HandleBackupOperationEventL Test"));
1.520 + DoOOMTestL(&CBackUpNotifierTest::RegisterForNotificationsTestL, _L("RegisterForNotificationsL Test"));
1.521 +
1.522 + __UHEAP_MARKEND;
1.523 + }
1.524 +
1.525 +//Initialise the Active Scheduler
1.526 +LOCAL_C void SetupL()
1.527 + {
1.528 + // Construct and install the active scheduler
1.529 + TheActiveScheduler = new(ELeave)CActiveScheduler;
1.530 + CActiveScheduler::Install(TheActiveScheduler);
1.531 + }
1.532 +
1.533 +
1.534 +GLDEF_C TInt E32Main()
1.535 + {
1.536 + __UHEAP_MARK;
1.537 +
1.538 + test.Printf(_L("\n"));
1.539 + test.Title();
1.540 + test.Start(_L("BackUp Notifier Tests"));
1.541 +
1.542 + TheTrapCleanup = CTrapCleanup::New();
1.543 +
1.544 + TRAPD(err, SetupL());
1.545 + test(err == KErrNone);
1.546 +
1.547 + TRAP(err, DoTestsL());
1.548 + test(err == KErrNone);
1.549 +
1.550 + delete TheTrapCleanup;
1.551 + delete TheActiveScheduler;
1.552 + test.End();
1.553 + test.Close();
1.554 +
1.555 + __UHEAP_MARKEND;
1.556 + return(KErrNone);
1.557 + }