--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mediator/tsrc/public/basic/src/MediatorTestCases.cpp Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,5976 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: ?Description
+*
+*/
+
+
+
+// INCLUDE FILES
+#include <e32math.h>
+#include <mediatorpluginbase.h>
+#include "MediatorTest.h"
+#include "mediatortestdata.h"
+
+using namespace MediatorService;
+
+// EXTERNAL DATA STRUCTURES
+//extern ?external_data;
+
+// EXTERNAL FUNCTION PROTOTYPES
+//extern ?external_function( ?arg_type,?arg_type );
+
+// CONSTANTS
+//const ?type ?constant_var = ?constant;
+const TInt KTestUid = 0x101FB3E7;
+const TInt KTestEventId = 1000;
+const TInt KNonExistingDomainId = 999;
+const TInt KReallyNonExistingDomainId = 1234567;
+const TInt KNonExistingCategoryId = 99;
+const TInt KNonExistingEventId = 99999;
+const TInt KExistingEventId = 50;
+const TInt KOtherUid = 0x00000124; // static domain defined in StaticEvents.rss
+const TInt KOtherSIDCategory = 0x00006767; // static category defined in StaticEvents.rss
+const TInt KOtherSIDEventId = 12; // static event defined in StaticEvents.rss
+const TInt KNonExistingEventCapaId = 5;
+const TInt KMinListId = 1;
+const TInt KMaxListId = 99;
+//const TInt KNonExistingCapsEventId = 889;
+const TInt KDefaultCommandId = 1000;
+const TInt KDefaultTimeOut = 3000; // 3 seconds
+const TInt KInvalidCommandId = 99999;
+const TInt KDataSize = 2000;
+const TInt KSecondaryCommandId = 700;
+const TInt KMinDomainID = 200100;
+const TInt KMidDomainID = 200150;
+const TInt KMaxDomainID = 200660;
+
+// MACROS
+//#define ?macro ?macro_def
+
+// LOCAL CONSTANTS AND MACROS
+//const ?type ?constant_var = ?constant;
+//#define ?macro_name ?macro_def
+
+// MODULE DATA STRUCTURES
+//enum ?declaration
+//typedef ?declaration
+
+// LOCAL FUNCTION PROTOTYPES
+//?type ?function_name( ?arg_type, ?arg_type );
+
+// FORWARD DECLARATIONS
+//class ?FORWARD_CLASSNAME;
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// ?function_name ?description.
+// ?description
+// Returns: ?value_1: ?description
+// ?value_n: ?description_line1
+// ?description_line2
+// -----------------------------------------------------------------------------
+//
+/*
+?type ?function_name(
+ ?arg_type arg, // ?description
+ ?arg_type arg) // ?description
+ {
+
+ ?code // ?comment
+
+ // ?comment
+ ?code
+ }
+*/
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::Case
+// Returns a test case by number.
+//
+// This function contains an array of all available test cases
+// i.e pair of case name and test function. If case specified by parameter
+// aCaseNumber is found from array, then that item is returned.
+//
+// The reason for this rather complicated function is to specify all the
+// test cases only in one place. It is not necessary to understand how
+// function pointers to class member functions works when adding new test
+// cases. See function body for instructions how to add new test case.
+// -----------------------------------------------------------------------------
+//
+const TCaseInfo CMediatorTest::Case (
+ const TInt aCaseNumber ) const
+ {
+
+ /**
+ * To add new test cases, implement new test case function and add new
+ * line to KCases array specify the name of the case and the function
+ * doing the test case
+ * In practice, do following
+ * 1) Make copy of existing test case function and change its name
+ * and functionality. Note that the function must be added to
+ * MediatorTest.cpp file and to MediatorTest.h
+ * header file.
+ *
+ * 2) Add entry to following KCases array either by using:
+ *
+ * 2.1: FUNCENTRY or ENTRY macro
+ * ENTRY macro takes two parameters: test case name and test case
+ * function name.
+ *
+ * FUNCENTRY macro takes only test case function name as a parameter and
+ * uses that as a test case name and test case function name.
+ *
+ * Or
+ *
+ * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used
+ * only with OOM (Out-Of-Memory) testing!
+ *
+ * OOM_ENTRY macro takes five parameters: test case name, test case
+ * function name, TBool which specifies is method supposed to be run using
+ * OOM conditions, TInt value for first heap memory allocation failure and
+ * TInt value for last heap memory allocation failure.
+ *
+ * OOM_FUNCENTRY macro takes test case function name as a parameter and uses
+ * that as a test case name, TBool which specifies is method supposed to be
+ * run using OOM conditions, TInt value for first heap memory allocation
+ * failure and TInt value for last heap memory allocation failure.
+ */
+
+ static TCaseInfoInternal const KCases[] =
+ {
+ // To add new test cases, add new items to this array
+ FUNCENTRY( RegisterOneEvent ),
+ FUNCENTRY( GetListOfDomainsInitL ),
+ FUNCENTRY( GetListOfDomains1DomainL ),
+ FUNCENTRY( GetListOfEvents1EventInCategoryL ),
+ FUNCENTRY( RegisterMultipleEventsL ),
+ FUNCENTRY( RegisterOver500EventsL ),
+ FUNCENTRY( UnregisterNonExistingEventDom ),
+ FUNCENTRY( GetListOfDomainsMultipleDomainsL ),
+ FUNCENTRY( UnregisterNonExistingEventCat ),
+ FUNCENTRY( UnregisterNonExistingEventEve ),
+ FUNCENTRY( UnregisterExistingEvent ),
+ FUNCENTRY( UnregisterRxistingEventDifferentSID ),
+ FUNCENTRY( UnregisterAListOfEventsL ),
+ FUNCENTRY( UnregisterAListOfEventsNotRegisteredL ),
+ FUNCENTRY( SubscribeToNonExistingEventDom ),
+ FUNCENTRY( SubscribeToNonExistingEventCat ),
+ FUNCENTRY( SubscribeToNonExistingEventEve ),
+ FUNCENTRY( SubscribeToWrongEventVersionMajor ),
+ FUNCENTRY( SubscribeToEventNonExistCapabilities ),
+ FUNCENTRY( SubscribeToEventCorrectParam ),
+ FUNCENTRY( SubscribeToListOfEventsCorrectParamL ),
+ FUNCENTRY( SubscribeToListOfEventsOneInfoIncorrectL ),
+ FUNCENTRY( RaiseNonExistingEventWrongDomainL ),
+ FUNCENTRY( RaiseNonExistingEventWrongCatL ),
+ FUNCENTRY( RaiseNonExistingEventEveL ),
+ FUNCENTRY( RaiseEventWithWrongEventVerMajorL ),
+ FUNCENTRY( RaiseEventRequiresNotExistingCapsInPubL ),
+ FUNCENTRY( RaiseExistingEventL ),
+ FUNCENTRY( SubscribeExistingEventRaiseFromPublisherSideL ),
+ FUNCENTRY( SubscribeExistingEventRaiseFromPublisherSideDataOver1kBL ),
+ FUNCENTRY( SubscribeToEventDeleteConsumerInstanceRaiseEventFromPublisherL ),
+ FUNCENTRY( Add2ndSubscriberToEventRaiseEventFromPublisherL ),
+ FUNCENTRY( UnsubscribeFrom1stSubscriberL ),
+ FUNCENTRY( SubscribeToEventRaise500TimesInLoopL ),
+ FUNCENTRY( RegisterOneCommandToMediator ),
+ FUNCENTRY( RegisterMultipleCommandsToMediatorL ),
+ FUNCENTRY( RegisterOver500CommandsWithinOneCatL ),
+ FUNCENTRY( RegisterCommandWithDomainUID0 ),
+ FUNCENTRY( RegisterCommandWithCategoryUID0 ),
+ FUNCENTRY( RegisterCommandWithCommandID0 ),
+ FUNCENTRY( RegisterCommandWithTimeoutValue0 ),
+ FUNCENTRY( IssueNonExistingCommandWrongDomainL ),
+ FUNCENTRY( IssueNonExistingCommandWrongCatL ),
+ FUNCENTRY( IssueNonExistingCommandIdL ),
+ FUNCENTRY( IssueCommandWrongCommandVerMajorL ),
+ FUNCENTRY( IssueCommandL ),
+ FUNCENTRY( IssueCommand2L ),
+ FUNCENTRY( IssueExistingCommandSameInitiatorWhileProcessingL ),
+ FUNCENTRY( IssueCommandWaitWithoutRespondingToCommandL ),
+ FUNCENTRY( IssueCommandCancelFromInitiatorBeforeTimeoutL ),
+ FUNCENTRY( IssueCommandRespondCorrectlyFromResponderL ),
+ FUNCENTRY( IssueCommandALotOfParameterDataL ),
+ FUNCENTRY( IssueCommandRespondALotOfResponseDataL ),
+ //FUNCENTRY( GetListOfDomainsOver500Domains ),
+ FUNCENTRY( GetListOfCategoriesNoCategoriesL ),
+ FUNCENTRY( GetListOfCategoriesIncorrectDomainUIDL ),
+ FUNCENTRY( GetListOfCategoriesMultipleCategoriesL ),
+ FUNCENTRY( GetListOfCommandsL ),
+ FUNCENTRY( GetListOfCommandsIncorrectDomainUIDL ),
+ FUNCENTRY( GetListOfCommandsIncorrectCategoryUIDL ),
+ FUNCENTRY( GetListOfCommands1CommandL ),
+ FUNCENTRY( GetListOfCommandsMultipleCommandsL ),
+ FUNCENTRY( GetListOfCommandsOver500CommandsL ),
+ FUNCENTRY( GetListOfEventsNoEventsInCategoryL ),
+ FUNCENTRY( GetListOfEventsWithIncorrectDomainUIDL ),
+ FUNCENTRY( GetListOfEventsWithIncorrectCategoryUIDL ),
+ FUNCENTRY( GetListOfEventsMultipleEventsInCategoryL ),
+ FUNCENTRY( GetListOfEventsOver500EventsInCategoryL ),
+ FUNCENTRY( SubscribeNotificationReceiver ),
+ FUNCENTRY( ReSubscribeNotificationReceiver ),
+ FUNCENTRY( ReUnsubscribeNotificationReceiver ),
+ FUNCENTRY( SubscribeNotificationReceiverRegisterCommandsL ),
+ FUNCENTRY( SubscribeNotificationReceiverUnregCommandsSoThatCatIsEmptyL ),
+ FUNCENTRY( SubscribeNotificationReceiverRegisterEventsL ),
+ FUNCENTRY( SubscribeNotificationReceiverUnregisterEventsL ),
+ FUNCENTRY( SubscribeNotificationReceiverUnregisterEventsSoThatCatIsEmptyL ),
+ FUNCENTRY( SubscribeNotificationReceiverRegisterCommandsSoThatErrorInRegistrationL ),
+ FUNCENTRY( SubscribeNotificationReceiverUnegisterCommandsSoThatErrorInRegistrationL ),
+ FUNCENTRY( SubscribeNotificationReceiverRegisterEventsSoThatErrorInRegistration ),
+ FUNCENTRY( SubscribeNotificationReceiverUnregisterEventsSoThatErrorInRegistration ),
+ FUNCENTRY( IssueCommandCancelAndReissueL ),
+ FUNCENTRY( IssueCommandCancelAndIssueNewCommandL ),
+ FUNCENTRY( InstantiateAndDeleteMediatorPluginL ),
+ FUNCENTRY( IssueCommandNoDataL ),
+ FUNCENTRY( RaiseEventNoDataL ),
+ FUNCENTRY( RegisterMultipleEventsWithMultipleUIDsL ),
+ FUNCENTRY( RegisterMultipleCommandsWithMultipleUIDsL ),
+ FUNCENTRY( IssueCommandRespondIncorrectlyFromResponderL ),
+ FUNCENTRY( OOMForEventProviderTestL ),
+ FUNCENTRY( OOMForEventConsumerTestL ),
+ FUNCENTRY( OOMForEventProviderwithListTestL ),
+ FUNCENTRY( OOMForEventConsumerWithEventTestL ),
+ FUNCENTRY( OOMForCommandInitiatorTestL ),
+ FUNCENTRY( OOMForCommandInitiatorCommandListTestL ),
+ FUNCENTRY( OOMForMediatorNotificationsTestL )
+ // Example how to use OOM functionality
+ //OOM_ENTRY( "Loop test with OOM", LoopTest, ETrue, 2, 3 ),
+ //OOM_FUNCENTRY( PrintTest, ETrue, 1, 3 ),
+ };
+
+ // Verify that case number is valid
+ if( (TUint) aCaseNumber >= sizeof( KCases ) /
+ sizeof( TCaseInfoInternal ) )
+ {
+ // Invalid case, construct empty object
+ TCaseInfo null( (const TText*) L"" );
+ null.iMethod = NULL;
+ null.iIsOOMTest = EFalse;
+ null.iFirstMemoryAllocation = 0;
+ null.iLastMemoryAllocation = 0;
+ return null;
+ }
+
+ // Construct TCaseInfo object and return it
+ TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );
+ tmp.iMethod = KCases[ aCaseNumber ].iMethod;
+ tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;
+ tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;
+ tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;
+ return tmp;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::PrintTest
+// Simple printing to UI test.
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::PrintTest(
+ TTestResult& aResult )
+ {
+ /* Simple print test */
+ _LIT( KPrintTest, "PrintTest" );
+ _LIT( KEnter, "Enter" );
+ _LIT( KOnGoing, "On-going" );
+ _LIT( KExit, "Exit" );
+
+ TestModuleIf().Printf( 0, KPrintTest, KEnter );
+
+ TestModuleIf().Printf( 1, KPrintTest, KOnGoing );
+
+ TestModuleIf().Printf( 0, KPrintTest, KExit );
+
+ // Test case passed
+
+ // Sets test case result and description(Maximum size is KStifMaxResultDes)
+ _LIT( KDescription, "PrintTest passed" );
+ aResult.SetResult( KErrNone, KDescription );
+
+ // Case was executed
+ return KErrNone;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::LoopTest
+// Another printing to UI test.
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::LoopTest( TTestResult& aResult )
+ {
+
+ /* Simple print and wait loop */
+ _LIT( KState, "State" );
+ _LIT( KLooping, "Looping" );
+
+ TestModuleIf().Printf( 0, KState, KLooping );
+
+ _LIT( KRunning, "Running" );
+ _LIT( KLoop, "%d" );
+ for( TInt i=0; i<10; i++)
+ {
+ TestModuleIf().Printf( 1, KRunning, KLoop, i);
+ User::After( 1000000 );
+ }
+
+ _LIT( KFinished, "Finished" );
+ TestModuleIf().Printf( 0, KState, KFinished );
+
+ // Test case passed
+
+ // Sets test case result and description(Maximum size is KStifMaxResultDes)
+ _LIT( KDescription, "LoopTest passed" );
+ aResult.SetResult( KErrNone, KDescription );
+
+ // Case was executed
+ return KErrNone;
+
+ }
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// M E D I A T O R T E S T S ->
+//
+//
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterOneEvent
+//
+// Register one event in Mediator
+// Expected precondition: No event created previously
+// Expected behaviour: Registration succeed
+// Cleaning: Unregister event
+//
+// Domain: KTestUid
+// Category: KTestUid
+// Event ID: KTestEventId
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterOneEvent( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iEventProvider->RegisterEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ caps ) ;
+
+ _LIT( KDescription, "RegisterEvent returns with" );
+ aResult.SetResult( status, KDescription ); // set status as test result
+
+ if( KErrNone == status )
+ {
+ /* Registration succeeded -> Clean Event */
+ TInt cleanStatus = CleanRegisterOneEvent( myUid, myUid, KTestEventId );
+ if( KErrNone != cleanStatus )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( cleanStatus, KDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+TInt CMediatorTest::CleanRegisterOneEvent( TUid aDomain, TUid aCategory, TInt aEventId )
+ {
+ return iEventProvider->UnregisterEvent( aDomain,
+ aCategory,
+ aEventId );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterMultipleEvents
+//
+// Register 50 events in Mediator
+// Expected precondition: No events created previously
+// Expected behaviour: Registration succeed
+// Cleaning: Unregister events
+//
+// Domain: KTestUid
+// Category: KTestUid
+// Event IDs: 50 - 99
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::RegisterMultipleEventsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList;
+ CleanupClosePushL( eventList );
+
+ for( TInt i=50; i<100; i++ ) // i = Event ID
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ status = iEventProvider->RegisterEvent( myUid,
+ myUid,
+ eventList);
+
+
+ _LIT( KDescription, "RegisterEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( KErrNone == status )
+ {
+ /* Registration succeeded -> Clean Event */
+ TInt cleanStatus = CleanRegisterMultipleEvents( myUid, myUid, eventList );
+ if( KErrNone != cleanStatus )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( cleanStatus, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CleanRegisterMultipleEvents( TUid aDomain, TUid aCategory, REventList& aEventList )
+ {
+ return iEventProvider->UnregisterEvent( aDomain,
+ aCategory,
+ aEventList );
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterOver500Events
+//
+// Register over 500 events
+// Expected precondition: No events created previously
+// Expected behaviour: Registration succeed
+// Cleaning: Unregister events
+//
+// Domain: KTestUid
+// Category: KTestUid
+// Event IDs: 100 - 699
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::RegisterOver500EventsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList;
+ CleanupClosePushL( eventList );
+
+ for( TInt i=100; i<700; i++ ) // i = event ID
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ status = iEventProvider->RegisterEvent( myUid,
+ myUid,
+ eventList);
+
+ _LIT( KDescription, "RegisterEvent returns with" );
+ aResult.SetResult( status, KDescription ); // status is returned as test result
+
+ if( KErrNone == status )
+ {
+ /* Registration succeeded -> Clean Events */
+ TInt cleanStatus = CleanRegisterOver500Events(myUid, myUid, eventList);
+ if( KErrNone != cleanStatus)
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( cleanStatus, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CleanRegisterOver500Events( TUid aDomain, TUid aCategory, REventList aEventList )
+ {
+ TInt status = iEventProvider->UnregisterEvent( aDomain,
+ aCategory,
+ aEventList );
+ CTestScheduler::StartAndStopL( 1000 ); // wait 1s
+
+ return status;
+ }
+
+ // -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterNonExistingEventDom
+//
+// Expected preconditions: Requested event domain is not existing
+// Expected behaviour: Unregistration fail (KErrMediatorDomainNotFound)
+// Cleaning: None
+//
+// Try to unregister event from domain that does not exist
+// Domain: KNonExistingDomainId
+// Category: KTestUid
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::UnregisterNonExistingEventDom( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingDomainId );
+
+ status = iEventProvider->UnregisterEvent( invalidUid,
+ myUid,
+ KTestEventId ) ;
+ //expected status is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KDescription, "UnregisterEvent returned with expected KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterNonExistingEventCat
+//
+// Expected preconditions: Requested event category is not existing
+// Expected behaviour: Unregistration fail (KErrMediatorCategoryNotFound)
+// Cleaning: None
+//
+// Try to unregister event from category that does not exist
+// Domain: KTestUid
+// Category: KNonExistingCategoryId
+// Event ID: KTestEventId
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::UnregisterNonExistingEventCat( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingCategoryId );
+ status = iEventProvider->UnregisterEvent( myUid,
+ invalidUid,
+ KTestEventId) ;
+ //expected status is KErrMediatorCategoryNotFound
+ if( KErrMediatorCategoryNotFound == status )
+ {
+ _LIT( KDescription, "UnregisterEvent returned with expected KErrMediatorCategoryNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+
+ return KErrNone;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterNonExistingEventEve
+//
+// Expected preconditions: Event is not existing but domain and category is
+// Expected behaviour: Unregistration fail (KErrMediatorEventNotFound)
+// Cleaning: Unregister existing events
+//
+// Try to unregister nonexisting event from valid Domain and Category
+// Domain: KTestUid
+// Category: KTestUid
+// Event ID: KNonExistingEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnregisterNonExistingEventEve( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KExistingEventId, iDefaultVersion, caps );
+
+ _LIT( KDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ //unregister non existing event
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid,
+ KNonExistingEventId);
+ //expected status is KErrMediatorEventNotFound
+ if( KErrMediatorEventNotFound == status )
+ {
+ _LIT( KDescription, "UnregisterEvent returned with expected KErrMediatorEventNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+
+ //clean existing event
+ status = CleanRegisterOneEvent( myUid, myUid, KExistingEventId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterExistingEvent
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Unregistration succeed (KErrNone)
+// Cleaning: Event is unregistered
+//
+// Unregister event
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KExistingEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnregisterExistingEvent( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KExistingEventId, iDefaultVersion, caps );
+
+ _LIT( KDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid,
+ KExistingEventId );
+ _LIT( KDescription, "UnregisterEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ }
+ return KErrNone;
+ }
+
+TInt CMediatorTest::PreconditionRegisterOneEvent( TUid aDomain,
+ TUid aCategory,
+ TInt aEventId,
+ TVersion aVersion,
+ TCapabilitySet aCaps )
+ {
+ TInt status( KErrNone );
+ status = iEventProvider->RegisterEvent( aDomain,
+ aCategory,
+ aEventId,
+ aVersion,
+ aCaps ) ;
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ return status;
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterRxistingEventDifferentSID
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Unregistration fail (KErrMediatorSecureIdMismatch)
+// Cleaning: Not needed
+//
+// Try to unregister event that is registered by different SID (static event)
+// Domain: KOtherUid
+// Category: KOtherSIDCategory
+// Event: KOtherSIDEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnregisterRxistingEventDifferentSID( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KOtherUid );
+ TUid myCat = TUid::Uid( KOtherSIDCategory );
+
+ // Precondition!!! Event is static, defined in resource file
+
+ status = iEventProvider->UnregisterEvent( myUid,
+ myCat,
+ KOtherSIDEventId) ;
+ //expected status is KErrMediatorSecureIdMismatch
+ if( KErrMediatorSecureIdMismatch == status ) // Event is registered by different SID
+ {
+ _LIT( KDescription, "UnregisterEvent returned with expected KErrMediatorSecureIdMismatch" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterAListOfEvents
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Unregistration succeed (KErrNone)
+// Cleaning: Not needed
+//
+// Unregister list of events
+// Domain: KTestUid
+// Category: KTestUid
+// Event ID(s): 51 - 75
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnregisterAListOfEventsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ for( TInt i=51; i<76; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ TInt preStatus = PreconditionRegisterAListOfEvents( myUid, myUid, eventList );
+ _LIT( KDescription, "PreconditionRegisterAListOfEvents returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid,
+ eventList );
+
+ _LIT( KDescription, "UnregisterEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ }
+
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+TInt CMediatorTest::PreconditionRegisterAListOfEvents( TUid aDomain,
+ TUid aCategory,
+ REventList aEventList )
+ {
+ return iEventProvider->RegisterEvent( aDomain,
+ aCategory,
+ aEventList );
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnregisterAListOfEventsNotRegistered
+//
+// Expected preconditions: Event does not exist
+// Expected behaviour: Unregistration fail (KErrMediatorEventNotFound)
+// Cleaning: Not needed
+//
+// Unregister list of event (some of events are not registered)
+// Domain: KTestUid
+// Category: KTestUid
+// Event ID(s): 73 - 103
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnregisterAListOfEventsNotRegisteredL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KExistingEventId, iDefaultVersion, caps );
+
+ _LIT( KDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+
+ for(TInt i=51; i<100; i++)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ //unregister a list of events that is not registered
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid,
+ eventList);
+ //expected status is KErrMediatorEventNotFound
+ if( KErrMediatorEventNotFound == status )
+ {
+ _LIT( KDescription, "UnregisterEvent returned with expected KErrMediatorEventNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ //clean the registered event
+ status = CleanRegisterOneEvent( myUid, myUid, KExistingEventId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToNonExistingEventDom
+//
+// Expected preconditions: Event does not exist
+// Expected behaviour: Subscribe fail (KErrMediatorDomainNotFound)
+// Cleaning: Not needed
+//
+// Try to subscribe to event (domain does not exist)
+// Domain: KNonExistingDomainId
+// Category: KTestUid
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToNonExistingEventDom( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingDomainId );
+
+ status = iEventConsumer->SubscribeEvent( invalidUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion) ;
+ //expected status is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KDescription, "SubscribeEvent returned with expected KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToNonExistingEventCat
+//
+// Expected preconditions: Event does not exist
+// Expected behaviour: Subscribe fail (KErrMediatorCategoryNotFound)
+// Cleaning: Not needed
+//
+// Try to subscribe event (category does not exist)
+// Domain: KTestUid
+// Category: KNonExistingCategoryId
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToNonExistingEventCat( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingCategoryId );
+
+ status = iEventConsumer->SubscribeEvent( myUid,
+ invalidUid,
+ KTestEventId,
+ iDefaultVersion ) ;
+ //expected status is KErrMediatorCategoryNotFound
+ if( KErrMediatorCategoryNotFound == status )
+ {
+ _LIT( KDescription, "SubscribeEvent returned with expected KErrMediatorCategoryNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToNonExistingEventEve
+//
+// Expected preconditions: Event does not exist
+// Expected behaviour: Subscribe fail (KErrMediatorEventNotFound)
+// Cleaning: Not needed
+//
+// Try to subscribe event (event does not exist)
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KNonExistingEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToNonExistingEventEve( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KExistingEventId, iDefaultVersion, caps );
+
+ _LIT( KDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KNonExistingEventId,
+ iDefaultVersion );
+ //expected status is KErrMediatorEventNotFound
+ if( KErrMediatorEventNotFound == status )
+ {
+ _LIT( KDescription, "SubscribeEvent returned with expected KErrMediatorEventNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ //unregister the registered event
+ status = CleanRegisterOneEvent( myUid, myUid, KExistingEventId );
+ if(KErrNone != status)
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToWrongEventVersionMajor
+//
+// Expected preconditions: Event does not exist
+// Expected behaviour: Subscribe fail (KErrMediatorVersionMismatch)
+// Cleaning: Not needed
+//
+// Try to subscribe event (event exist but version is wrong)
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KTestEventId
+// Version: 6.5.5
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToWrongEventVersionMajor( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TVersion version( 777, 5, 5 );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+
+ _LIT( KDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ version );
+ //expected status is KErrMediatorVersionMismatch
+ if( KErrMediatorVersionMismatch == status )
+ {
+ _LIT( KDescription, "SubscribeEvent returned with expected KErrMediatorVersionMismatch" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterOneEvent(myUid, myUid, KTestEventId);
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToEventNonExistCapabilities
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Subscribe fail (KErrPermissionDenied)
+// Cleaning: Not needed
+//
+// Try to subscribe event that require too much capabilities
+// Domain: KOtherUid
+// Category: KOtherSIDCategory
+// Event: KNonExistingEventCapaId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToEventNonExistCapabilities( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KOtherUid );
+ TUid catUid = TUid::Uid( KOtherSIDCategory );
+ TVersion version( 1,0,0 );
+
+ status = iEventConsumer->SubscribeEvent( myUid,
+ catUid,
+ KNonExistingEventCapaId,
+ version);
+ //expected status is KErrPermissionDenied
+ if( KErrPermissionDenied == status )
+ {
+ _LIT( KDescription, "SubscribeEvent returned with expected KErrPermissionDenied" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToEventCorrectParam
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Subscribe succeed (KErrNone)
+// Cleaning: Unsubscribe event
+//
+// Subscribe event
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToEventCorrectParam( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion );
+
+ _LIT( KErrorDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ if( KErrNone == status )
+ {
+ status = CleanSubscribeToEvent( myUid, myUid, KTestEventId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test (SubscribeEvent) passed but unsubscribe failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ //unregister the registered event
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CleanSubscribeToEvent( TUid aDomain,
+ TUid aCategory,
+ TInt aEventId )
+ {
+ return iEventConsumer->UnsubscribeEvent( aDomain,
+ aCategory,
+ aEventId ) ;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToListOfEventsCorrectParam
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Subscribe succeed (KErrNone)
+// Cleaning: Unsubscribe event
+//
+// Subscribe list of events
+// Domain: KTestUid
+// Category: KTestUid
+// Events: 80 - 90
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToListOfEventsCorrectParamL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ for( TInt i=80; i<91; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+ TInt preStatus = PreconditionRegisterEvents( myUid, myUid, eventList );
+ _LIT( KDescription, "PreconditionRegisterEvents returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ eventList );
+
+ _LIT( KDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanSubscribeToListOfEvents( myUid, myUid, eventList );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test(SubscribeEvent) passed but unsbscribe failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ //clean registered events
+ status = CleanRegisterMultipleEvents( myUid, myUid, eventList );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning events failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+TInt CMediatorTest::PreconditionRegisterEvents( TUid aDomain,
+ TUid aCategory,
+ REventList aEvents )
+ {
+ return iEventProvider->RegisterEvent( aDomain, aCategory, aEvents);
+ }
+
+TInt CMediatorTest::CleanSubscribeToListOfEvents( TUid aDomain,
+ TUid aCategory,
+ REventList aEvents )
+ {
+ return iEventConsumer->UnsubscribeEvent( aDomain,
+ aCategory,
+ aEvents ) ;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToListOfEventsOneInfoIncorrect
+//
+// Expected preconditions: Event is existing
+// Expected behaviour: Subscribe fail (KErrMediatorVersionMismatch)
+// Cleaning: Unsubscribe event
+//
+// Subscribe to list of events (one item in list not valid)
+// Domain: KTestUid
+// Category; KTestUid
+// Events: 91 - KMaxListId (One event version is incorrect)
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToListOfEventsOneInfoIncorrectL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TVersion invalidVersion( 6, 5, 5 );
+
+ REventList eventList;
+ CleanupClosePushL( eventList );
+
+ for( TInt i=91; i<101; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ REventList myList = eventList;
+
+ TInt preStatus = PreconditionRegisterEvents( myUid, myUid, myList );
+ _LIT( KErrorDescription, "PreconditionRegisterEvents returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TEvent newEvent;
+ newEvent.iEventId = 100;
+ newEvent.iVersion = invalidVersion;//wrong version
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ eventList );
+ //expected status is KErrMediatorVersionMismatch
+ if( KErrMediatorVersionMismatch == status )
+ {
+ _LIT( KDescription, "SubscribeEvent returned with expected KErrMediatorVersionMismatch" );
+ aResult.SetResult( KErrNone, KDescription );
+ //clean the registered events
+ status = CleanRegisterMultipleEvents( myUid, myUid, myList );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RaiseNonExistingEventWrongDomain
+//
+// Expected preconditions: There are domains but requested domain does not exist
+// Expected behaviour: Raise fail (KErrMediatorDomainNotFound)
+// Cleaning: Not needed
+//
+// Try to raise event (event not registered)
+// Domain: KNonExistingDomainId
+// Category: KTestUid
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RaiseNonExistingEventWrongDomainL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid invalidUid = TUid::Uid( KNonExistingDomainId );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ _LIT8( KTest, "TestTestTest" );
+ HBufC8* data = KTest().AllocLC();
+ status = iEventProvider->RaiseEvent( invalidUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+
+ CleanupStack::PopAndDestroy( data );
+ //expected status is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KDescription, "RaiseEvent returned with expected KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RaiseNonExistingEventWrongCat
+//
+// Expected preconditions: There are domains but requested category does not exist
+// Expected behaviour: Raise fail (KErrMediatorCategoryNotFound)
+// Cleaning: Not needed
+//
+// Try to raise event (category does not exist)
+// Domain: KOtherUid
+// Category: KNonExistingCategoryId
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RaiseNonExistingEventWrongCatL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid invalidUid = TUid::Uid( KNonExistingCategoryId );
+ TUid myUid = TUid::Uid(KOtherUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ _LIT8( KTest, "TestTestTest" );
+ HBufC8* data = KTest().AllocLC();
+
+ status = iEventProvider->RaiseEvent( myUid,
+ invalidUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+
+ CleanupStack::PopAndDestroy( data );
+ //expected status is KErrMediatorCategoryNotFound
+ if( KErrMediatorCategoryNotFound == status )
+ {
+ _LIT( KDescription, "RaiseEvent returned with expected KErrMediatorCategoryNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RaiseNonExistingEventEve
+//
+// Expected preconditions: There is domain and category but requested event does not exist
+// Expected behaviour: Raise fail (KErrMediatorEventNotFound)
+// Cleaning: Unregister event
+//
+// Raise event (event does not exist)
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KNonExistingEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RaiseNonExistingEventEveL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ _LIT8( KTest, "TestTestTest" );
+ HBufC8* data = KTest().AllocLC();
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ if( KErrNone == status )
+ {
+ status = iEventProvider->RaiseEvent( myUid,
+ myUid,
+ KNonExistingEventId,
+ iDefaultVersion,
+ *data );
+ CleanupStack::PopAndDestroy( data );
+ //expected status is KErrMediatorEventNotFound
+ if( KErrMediatorEventNotFound == status )
+ {
+ _LIT( KDescription, "RaiseEvent returned with expected KErrMediatorEventNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RaiseEventWithWrongEventVerMajor
+//
+// Expected preconditions: There is domain and category but requested event version does not exist
+// Expected behaviour: Raise fail (KErrMediatorVersionMismatch)
+// Cleaning: Not needed
+//
+// Try to raise event (wrong version)
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RaiseEventWithWrongEventVerMajorL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TVersion version( 888, 5, 5 );
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ _LIT8( KTest, "TestTestTest" );
+ HBufC8* data = KTest().AllocLC();
+ status = iEventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ version,
+ *data );
+ CleanupStack::PopAndDestroy( data );
+ //expected status is KErrMediatorVersionMismatch
+ if( KErrMediatorVersionMismatch == status )
+ {
+ _LIT( KDescription, "RaiseEvent returned with expected KErrMediatorVersionMismatch" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RaiseEventRequiresNotExistingCapsInPub
+//
+// Expected preconditions: There is domain and category but requested event capabilites does not exist
+// Expected behaviour: Raise fail (KErrMediatorDomainNotFound)
+// Cleaning: Not needed
+//
+// Raise event that requires capabilities not existing in publisher
+// Domain: KTestUid
+// Category: KTestUid
+// Event: KNonExistingEventCapaId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RaiseEventRequiresNotExistingCapsInPubL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KOtherUid );
+ TUid catUid = TUid::Uid( KOtherSIDCategory );
+ TVersion version( 1, 0 ,0 );
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ status = iEventProvider->RaiseEvent( myUid,
+ catUid,
+ KNonExistingEventCapaId, // static event
+ version,
+ *data );
+ CleanupStack::PopAndDestroy( data );
+
+ _LIT( KErrorDescription, "" );
+ aResult.SetResult( status, KErrorDescription );
+
+ return KErrNone;
+}
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RaiseExistingEvent
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Raise succeed
+// Cleaning: Event unregistered
+//
+// Raise event
+// Domain: KTestUid
+// Category: KTestUid
+// Event ID: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RaiseExistingEventL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "Preconditions failed" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+ // wait 3s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL( 3000 );
+
+ CleanupStack::PopAndDestroy( data );
+ CleanupStack::PopAndDestroy( eventProvider );
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ status = CleanRegisterOneEvent(myUid, myUid, KTestEventId);
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test Passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeExistingEventRaiseFromPublisherSide
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Raise succeed
+// Cleaning: Event unregistered
+//
+// Raise event
+// Domain: KTestUid
+// Category: KTestUid
+// Event ID: KTestEventId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeExistingEventRaiseFromPublisherSideL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ // Clear all notify information from helper
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion) ;
+ CTestScheduler::StartAndStopL( 1000 ); // 1s delay
+
+ if( KErrNone == status )
+ {
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+ // wait 2s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ /* Check that notify was received, only when RaiseEvent returns KErrNone*/
+ if ( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iEventId != KTestEventId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId ) ;
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ CleanupStack::PopAndDestroy( eventProvider );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeExistingEventRaiseFromPublisherSideDataOver1kB
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Raise succeed
+// Cleaning: Event unregistered
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeExistingEventRaiseFromPublisherSideDataOver1kBL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+
+ // Clear all notify information from helper
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion ) ;
+
+ HBufC8* data = HBufC8::NewLC( KDataSize );
+ TPtr8 dataPtr = data->Des();
+ for( TInt i = 0; i < KDataSize; i++ )
+ {
+ TChar tmpChar(64);
+ dataPtr.Append( tmpChar );
+ }
+ _LIT( KDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ // wait 2s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL(2000);
+
+ /* Check that notify was received, only when RaiseEvent returns KErrNone*/
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iEventId != KTestEventId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId ) ;
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ CleanupStack::PopAndDestroy( eventProvider );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToEventDeleteConsumerInstanceRaiseEventFromPublisher
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Raise succeed
+// Cleaning: Event unregistered
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToEventDeleteConsumerInstanceRaiseEventFromPublisherL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ // Clear all notify information from helper
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps);
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ CMediatorEventConsumer* eventConsumer = CMediatorEventConsumer::NewL( iTestHelper );
+ CleanupStack::PushL( eventConsumer );
+ if( KErrNone == preStatus )
+ {
+ status = eventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion ) ;
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ _LIT( KDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ // wait 2s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL(2000);
+ /* Check that notify was received, only when RaiseEvent returns KErrNone*/
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iEventId != KTestEventId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ //clean the registered event
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId ) ;
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( eventProvider );
+ }
+ CleanupStack::PopAndDestroy( data );
+ }
+ CleanupStack::PopAndDestroy(eventConsumer);
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::Add2ndSubscriberToEventRaiseEventFromPublisher
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Raise succeed
+// Cleaning: Event unregistered
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::Add2ndSubscriberToEventRaiseEventFromPublisherL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ CMediatorEventConsumer* eventConsumer = CMediatorEventConsumer::NewL( iTestHelper );
+ CleanupStack::PushL( eventConsumer );
+ CMediatorEventConsumer* otherEventConsumer = CMediatorEventConsumer::NewL( iAnotherTestHelper );
+ CleanupStack::PushL( otherEventConsumer );
+ iTestHelper->ClearAllNotifyData();
+ iAnotherTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = eventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion );
+ TInt status2( KErrNone );
+ status2 = otherEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion);
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ _LIT( KDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( ( KErrNone == status2 ) && ( KErrNone ==status ) )
+ {
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ // wait 2s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL(2000);
+ /* Check that notify was received for both notification, only when RaiseEvent returns KErrNone*/
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iEventId != KTestEventId ) )
+
+ &&( ( iAnotherTestHelper->iNotificationReceived == 0 )
+ || ( iAnotherTestHelper->iDomain != myUid )
+ || ( iAnotherTestHelper->iCategory != myUid )
+ || ( iAnotherTestHelper->iEventId != KTestEventId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId ) ;
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( eventProvider );
+ }
+ CleanupStack::PopAndDestroy( data );
+ }
+ CleanupStack::PopAndDestroy( otherEventConsumer );
+ CleanupStack::PopAndDestroy( eventConsumer );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnsubscribeFrom1stSubscriber
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Raise succeed
+// Cleaning: Event unregistered
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnsubscribeFrom1stSubscriberL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ CMediatorEventConsumer* eventConsumer = CMediatorEventConsumer::NewL( iTestHelper );
+ CleanupStack::PushL( eventConsumer );
+ CMediatorEventConsumer* otherEventConsumer = CMediatorEventConsumer::NewL( iAnotherTestHelper );
+ CleanupStack::PushL( otherEventConsumer );
+ iTestHelper->ClearAllNotifyData();
+ iAnotherTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = eventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion );
+ TInt status2( KErrNone );
+ status2 = otherEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion);
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ _LIT( KDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( ( KErrNone == status2 ) && ( KErrNone ==status ) )
+ {
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+ status = otherEventConsumer->UnsubscribeEvent( myUid,
+ myUid,
+ KTestEventId);
+ _LIT( KDescription, "UnsubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ // wait 2s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL(2000);
+
+ /* Check that notify was received for only one notification, only when RaiseEvent returns KErrNone*/
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iEventId != KTestEventId ) )
+
+ &&( ( iAnotherTestHelper->iNotificationReceived != 0 )
+ || ( iAnotherTestHelper->iDomain == myUid )
+ || ( iAnotherTestHelper->iCategory == myUid )
+ || ( iAnotherTestHelper->iEventId == KTestEventId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "notifications check failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId ) ;
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( eventProvider );
+ }
+ CleanupStack::PopAndDestroy( data );
+ }
+ CleanupStack::PopAndDestroy( otherEventConsumer );
+ CleanupStack::PopAndDestroy( eventConsumer );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeToEventRaise500TimesInLoop
+//
+// Expected preconditions: Event exist
+// Expected behaviour: Subscribe and raise succeed
+// Cleaning: Event unregistered
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeToEventRaise500TimesInLoopL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventConsumer->SubscribeEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion );
+ _LIT( KDescription, "SubscribeEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ for(TInt i=0; i<550; i++)
+ {
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ *data );
+ if( KErrNone != status)
+ {
+ break;
+ }
+ }
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ // wait 2s to make sure that all asyncronous events are completed
+ CTestScheduler::StartAndStopL(2000);
+
+ /* Check that notify was received, only when RaiseEvent returns KErrNone*/
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iEventId != KTestEventId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ //clean the registered event
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId ) ;
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ CleanupStack::PopAndDestroy( eventProvider );
+ }
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterOneCommandToMediator
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Command unregistered
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterOneCommandToMediator( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CleanRegisterCommand( TUid aDomain,
+ TUid aCategory,
+ TInt aCommandId )
+ {
+ TInt status = iCommandResponder->UnregisterCommand( aDomain,
+ aCategory,
+ aCommandId );
+ CTestScheduler::StartAndStopL( 1000 ); // wait 1s
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterMultipleCommandsToMediator
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Command unregistered
+//
+// Register multiple commands
+// Command ID(s): 1 - KMaxListId
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterMultipleCommandsToMediatorL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ RCommandList commands;
+ CleanupClosePushL(commands);
+ for ( TInt index = KMinListId; index <KMaxListId; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ commands.AppendL( newCommand );
+ }
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ commands );
+
+ _LIT( KDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommands( myUid,
+ myUid,
+ commands );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &commands );
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CleanRegisterCommands( TUid aDomain,
+ TUid aCategory,
+ RCommandList aCommands )
+ {
+
+ TInt status = iCommandResponder->UnregisterCommand( aDomain,
+ aCategory,
+ aCommands );
+ CTestScheduler::StartAndStopL( 2000 ); // wait 1s
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterOver500CommandsWithinOneCat
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Command unregistered
+//
+// IDs: KMaxListId - (KMaxListId + 540)
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterOver500CommandsWithinOneCatL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ RCommandList commands;
+ CleanupClosePushL(commands);
+
+ for ( TInt index = KMaxListId; index <KMaxListId+540; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ User::LeaveIfError( commands.Append( newCommand ) );
+ }
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ commands );
+
+ _LIT( KDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommands( myUid,
+ myUid,
+ commands );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &commands );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterCommandWithDomainUID0
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Command unregistered
+//
+// Register command
+// Domain: 0
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterCommandWithDomainUID0( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid invalidUid = TUid::Uid(0);
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ invalidUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid, invalidUid, KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterCommandWithCategoryUID0
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command fail
+// Cleaning: Not needed
+//
+// Register command with category 0
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterCommandWithCategoryUID0( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid(0);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ invalidUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid, invalidUid, KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterCommandWithCommandID0
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Unregister command
+//
+// REgister command with command ID 0
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterCommandWithCommandID0( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ 0,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid, myUid, 0 );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterCommandWithTimeoutValue
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Unregister command
+//
+// Register command with time out 0
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::RegisterCommandWithTimeoutValue0( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ KSecondaryCommandId,
+ iDefaultVersion,
+ caps,
+ 0 ); // time out
+ _LIT( KErrorDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid, myUid, KSecondaryCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueNonExistingCommandWrongDomain
+//
+// Expected preconditions: Command domain does not exist
+// Expected behaviour: Issue command fail
+// Cleaning: Not needed
+//
+// Try to issue command
+// Domain not valid
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueNonExistingCommandWrongDomainL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingDomainId );
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ status = iCommandInitiator->IssueCommand( invalidUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data);
+ CleanupStack::PopAndDestroy( data );
+ //expected status is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KDescription, "IssueCommand returns with expected KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CTestScheduler::StartAndStopL( 5000 ); // wait 5s
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueNonExistingCommandWrongCat
+//
+// Expected preconditions: Command category does not exist
+// Expected behaviour: Issue command fail
+// Cleaning: Not needed
+//
+// Try to issue command
+// Category not valid
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueNonExistingCommandWrongCatL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingCategoryId );
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ status = iCommandInitiator->IssueCommand( myUid,
+ invalidUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data);
+ CleanupStack::PopAndDestroy( data );
+ //expected status is KErrMediatorCategoryNotFound
+ if( KErrMediatorCategoryNotFound == status )
+ {
+ _LIT( KDescription, "IssueCommand returns with expected KErrMediatorCategoryNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CTestScheduler::StartAndStopL( 2000 ); // wait 2s
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueNonExistingCommandId
+//
+// Expected preconditions: Register a command and issue a command with invalid command id
+// Expected behaviour: Issue command fail
+// Cleaning: Unregister command
+//
+// Try to issue command
+// Command ID not valid
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueNonExistingCommandIdL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ status = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ if( KErrNone == status )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KInvalidCommandId,//command does not exist
+ iDefaultVersion,
+ *data );
+
+ //expected status is KErrMediatorCommandNotFound
+ if( KErrMediatorCommandNotFound == status )
+ {
+ _LIT( KDescription, "IssueCommand returns with expected KErrMediatorCommandNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test Passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ CTestScheduler::StartAndStopL( 2000 ); // wait 3s
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandWrongCommandVerMajor
+//
+// Expected preconditions: Command version does not exist
+// Expected behaviour: Issue command fail
+// Cleaning: Unregister command
+//
+// Try to issue command
+// Wrong version
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandWrongCommandVerMajorL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TVersion version( 666,5,5);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ 1000 );
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ version,
+ *data );
+
+ CTestScheduler::StartAndStopL(2000); // wait 2s
+ //expected status is KErrMediatorVersionMismatch
+ if( KErrMediatorVersionMismatch == status )
+ {
+ _LIT( KDescription, "IssueCommand returns with expected KErrMediatorVersionMismatch" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test Passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+TInt CMediatorTest::PreconditionRegisterCommand( TUid aDomain,
+ TUid aCategory,
+ TInt aCommandId,
+ TVersion aVersion,
+ TCapabilitySet aCaps,
+ TInt aTimeOut )
+ {
+ TInt status = iCommandResponder->RegisterCommand( aDomain,
+ aCategory,
+ aCommandId,
+ aVersion,
+ aCaps,
+ aTimeOut );
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ return status;
+ }
+
+TInt CMediatorTest::PreconditionRegisterCommands( TUid aDomain,
+ TUid aCategory,
+ RCommandList aCommands )
+ {
+ TInt status = iCommandResponder->RegisterCommand( aDomain,
+ aCategory,
+ aCommands );
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ return status;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommand
+//
+// Issue command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ iTestHelper->ClearAllNotifyData( );
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data );
+ CTestScheduler::StartAndStopL(2000); // wait 2s
+
+
+ _LIT( KDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( KErrNone == status )
+ {
+ _LIT8(KTestR, "Command response here");
+ HBufC8* replyData = KTestR().AllocLC();
+ status = iCommandResponder->IssueResponse( iTestHelper->iDomain,
+ iTestHelper->iCategory,
+ iTestHelper->iCommandId,
+ KErrNone,
+ *replyData );
+ if( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test Passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ _LIT( KErrorDescription, "IssueResponse returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ CleanupStack::PopAndDestroy( replyData );
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommand2
+//
+// Issue command from here.
+// Command receiver implemented in plugin. Reply is expected
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::IssueCommand2L( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid(0x999101);
+ TVersion version( 1,0,0);
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ CMediatorCommandInitiator *commandInitiator = CMediatorCommandInitiator::NewL( iTestHelper );
+ CleanupStack::PushL( commandInitiator );
+ TInt invalidCmd = 1;
+ commandInitiator->CancelCommand( myUid,
+ myUid,
+ invalidCmd );
+
+ status = commandInitiator->IssueCommand( myUid,
+ myUid,
+ invalidCmd,
+ version,
+ *data );
+
+ CTestScheduler::StartAndStopL(2000); // wait 2s
+
+ // Check that reply was received
+ if( ( iTestHelper->iNotificationReceived == ECommandResponse ) && ( KErrNone == status ) )
+ {
+ _LIT( KDescription, "IssueCommand gets notification" );
+ aResult.SetResult( status, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Error" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ iTestHelper->ClearAllNotifyData( );
+ commandInitiator->CancelCommand( myUid,
+ myUid,
+ invalidCmd );
+
+ CleanupStack::PopAndDestroy( commandInitiator );
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueExistingCommandSameInitiatorWhileProcessing
+// Issue command twice with same command initiator
+// Expected preconditions: None
+// Expected behaviour: KErrInUse
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+
+
+TInt CMediatorTest::IssueExistingCommandSameInitiatorWhileProcessingL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KMinListId,
+ iDefaultVersion,
+ caps,
+ 5000 );
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KMinListId,
+ iDefaultVersion,
+ *data );
+ CTestScheduler::StartAndStopL( 2000 ); // wait 2s
+ if( KErrNone == status )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KMinListId,
+ iDefaultVersion,
+ *data );
+
+ if ( KErrInUse == status )
+ {
+ _LIT( KErrorDescription, "IssueCommand returns with expected KErrInUse " );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KMinListId );
+ CTestScheduler::StartAndStopL( 2000 );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test code passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandWaitWithoutRespondingToCommand
+// Issue command and wait for some time and check the notification
+// Expected preconditions: None
+// Expected behaviour:
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandWaitWithoutRespondingToCommandL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KMinListId+1,
+ iDefaultVersion,
+ caps,
+ 5000 );
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KMinListId+1,
+ iDefaultVersion,
+ *data );
+
+ CTestScheduler::StartAndStopL(2000); // wait 2s
+ _LIT( KErrorDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ /* Check that notify was received, only when RaiseEvent returns KErrNone*/
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iCommandId != KMinListId+1 ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ //clean the registered command
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KMinListId+1 );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning command failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+}
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandCancelFromInitiatorBeforeTimeout
+// Issue command and cancel it before timeout.
+// Expected preconditions: register command with specific time
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandCancelFromInitiatorBeforeTimeoutL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ iTestHelper->ClearAllNotifyData();
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KMinListId+2,
+ iDefaultVersion,
+ caps,
+ 5000 );
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KMinListId+2,
+ iDefaultVersion,
+ *data );
+ _LIT( KErrorDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ if( KErrNone == status )
+ {
+ iCommandInitiator->CancelCommand( myUid,
+ myUid,
+ KMinListId+2 );
+
+ CTestScheduler::StartAndStopL( 2000 ); // wait 2s
+
+ status = CleanRegisterCommand(myUid,
+ myUid,
+ KMinListId+2);
+
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandRespondCorrectlyFromResponder
+// Issue command, get the correct reposonse from command responder
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandRespondCorrectlyFromResponderL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ iTestHelper->ClearAllNotifyData();
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ 5000 );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data );
+
+ CTestScheduler::StartAndStopL(1000);
+ _LIT( KDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ _LIT8(KTestR, "Command response here");
+ HBufC8* replyData = KTestR().AllocLC();
+ status = iCommandResponder->IssueResponse( iTestHelper->iDomain,
+ iTestHelper->iCategory,
+ iTestHelper->iCommandId,
+ KErrNone,
+ *replyData );
+ CleanupStack::PopAndDestroy( replyData );
+
+ _LIT( KErrorDescription, "IssueResponse returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandRespondIncorrectlyFromResponderL
+// Issue command and get the wrong reposonse from command responder
+// Expected preconditions: IssueResponse with wrong category id
+// Expected behaviour: KErrMediatorCommandNotFound
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+
+
+TInt CMediatorTest::IssueCommandRespondIncorrectlyFromResponderL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid(KNonExistingCategoryId);
+
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ 5000 );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data );
+
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ _LIT( KDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ _LIT8(KTestR, "Command response here");
+ HBufC8* replyData = KTestR().AllocLC();
+ status = iCommandResponder->IssueResponse( iTestHelper->iDomain,
+ invalidUid, // This is is incorrect value in reply
+ iTestHelper->iCommandId,
+ KErrNone,
+ *replyData );
+ CleanupStack::PopAndDestroy( replyData );
+
+ if( KErrMediatorCommandNotFound != status )
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "IssueResponse returns with" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandALotOfParameterData
+// Issue command with big amount of data
+// Expected preconditions: IssueCommand with big data buffer
+// Expected behaviour: IssueCommand returns with KErrNone
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandALotOfParameterDataL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+
+ HBufC8* data = HBufC8::NewLC( KDataSize );
+ TPtr8 dataPtr = data->Des();
+ for( TInt i = 0; i < KDataSize; i++ )
+ {
+ TChar tmpChar( 64 );
+ dataPtr.Append( tmpChar );
+ }
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ 5000 );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data );
+
+ CTestScheduler::StartAndStopL(2000); // wait 2s
+ _LIT( KErrorDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ /* Check that notify was received, */
+ if( ( KErrNone == status )
+ &&( ( iTestHelper->iNotificationReceived == 0 )
+ || ( iTestHelper->iDomain != myUid )
+ || ( iTestHelper->iCategory != myUid )
+ || ( iTestHelper->iCommandId != KDefaultCommandId ) ) )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper checks failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ //clean the registered command
+ else if ( KErrNone == status )
+ {
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning command failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandRespondALotOfResponseData
+// IssueResponse with big amount of data
+// Expected preconditions: IssueResponse with big data buffer
+// Expected behaviour: IssueResponse returns with KErrNone
+// Cleaning: Unregister command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandRespondALotOfResponseDataL( TTestResult& aResult )
+{
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+
+ _LIT8(KTest, "Replywithalotofdata");
+ HBufC8* data = KTest().AllocLC();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ 5000 );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ *data );
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "IssueCommand returns with" );
+ aResult.SetResult( status, KDescription );
+ HBufC8* rData = HBufC8::NewLC( KDataSize );
+ TPtr8 dataPtr = rData->Des();
+ for( TInt i = 0; i < KDataSize; i++ )
+ {
+ TChar tmpChar(64);
+ dataPtr.Append( tmpChar );
+ }
+
+ status = iCommandResponder->IssueResponse( iTestHelper->iDomain,
+ iTestHelper->iCategory,
+ iTestHelper->iCommandId,
+ KErrNone,
+ *rData );
+ CleanupStack::PopAndDestroy( rData );
+
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "IssueResponse returns with" );
+ aResult.SetResult( KErrNone, KDescription );
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+ CTestScheduler::StartAndStopL(1000); // wait 1s
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( data );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfDomainsNoDomains
+//
+// Get list of domains
+// Expected: 0 domains
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfDomainsNoDomainsL( TTestResult& aResult )
+ {
+ // There shall not be any domains when executing this test
+ RDomainList domainList;
+ CleanupClosePushL( domainList );
+ TInt status = iNotifications->GetDomains( domainList );
+
+ if( KErrNone == status )
+ {
+ if( domainList.Count() == 0 )
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Registered domains found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &domainList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfDomainsInit
+//
+// Get list of domains
+// Expected: Unknown count of domains
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfDomainsInitL( TTestResult& aResult )
+ {
+ RDomainList domainList;
+ CleanupClosePushL( domainList );
+ TInt status = iNotifications->GetDomains( domainList );
+
+ if( KErrNone == status )
+ {
+ initCountOfDomain = domainList.Count();
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &domainList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfDomains1Domain
+//
+// Get list of domains
+// Expected 1 domain (+already existing)
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfDomains1DomainL( TTestResult& aResult )
+ {
+ // There shall be one domain when executing this test
+ RDomainList domainList;
+ CleanupClosePushL( domainList );
+ TInt status = iNotifications->GetDomains( domainList );
+
+ if( KErrNone == status )
+ {
+ if( domainList.Count() == initCountOfDomain )
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of domains found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &domainList );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfDomainsMultipleDomains
+//
+// Get list of domains
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfDomainsMultipleDomainsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TUid domain;
+
+ REventList eventList;
+ CleanupClosePushL(eventList);
+
+ for(TInt i=50; i<100; i++) // i = Event ID
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL(newEvent);
+ }
+
+ for( TInt j=KMinDomainID; j<KMidDomainID; j++ ) // j = domain
+ {
+ domain = TUid::Uid(j);
+ status = iEventProvider->RegisterEvent( domain,
+ myUid,
+ eventList );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Register event failure" );
+ aResult.SetResult( status, KErrorDescription );
+ break;
+ }
+ }
+ // There shall be multiple domain when executing this test
+ if ( KErrNone == status )
+ {
+ RDomainList domainList;
+ CleanupClosePushL(domainList);
+ status = iNotifications->GetDomains( domainList );
+
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ if( KErrNone == status )
+ {
+ if(domainList.Count() > 1 )
+ {
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of domains found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &domainList );
+ }
+ status = CleanRegisterMultipleEvents(domain, myUid, eventList);
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfDomainsOver500Domains
+//
+// Get list of domains
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfDomainsOver500DomainsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TUid domain;
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ for( TInt i=50; i<100; i++ ) // i = Event ID
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL(newEvent);
+ }
+
+ for( TInt j=KMidDomainID; j<KMaxDomainID; j++ ) // j = domain
+ {
+ domain = TUid::Uid(j);
+ status = iEventProvider->RegisterEvent( domain,
+ myUid,
+ eventList );
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Register event failure" );
+ aResult.SetResult( status, KErrorDescription );
+ break;
+ }
+ }
+ if( KErrNone == status )
+ {
+
+ // There shall be over 500 domain when executing this test
+ RDomainList domainList;
+ CleanupClosePushL( domainList );
+ status = iNotifications->GetDomains( domainList );
+
+ if(KErrNone == status )
+ {
+ if(domainList.Count() > 500 )
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of domains found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetDomains returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+
+ for( TInt j=KMidDomainID; j<KMaxDomainID; j++ ) // j = domain
+ {
+ domain = TUid::Uid(j);
+ status = CleanRegisterMultipleEvents(domain, myUid, eventList);
+ if(KErrNone != status)
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &domainList );
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCategoriesNoCategories
+//
+// Get list of categories
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::GetListOfCategoriesNoCategoriesL( TTestResult& aResult )
+ {
+ // There shall not be categories in domain
+ RCategoryList categoryList;
+ CleanupClosePushL( categoryList );
+ TUid myUid = TUid::Uid( KTestUid );
+ iTestHelper->ClearAllNotifyData();
+ TInt status = iNotifications->GetCategories( myUid, categoryList );
+
+ if( KErrNone == status )
+ {
+ if( categoryList.Count() == 0 )
+ {
+ _LIT( KErrorDescription, "GetCategories returns with" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong number of categories found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetCategories returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &categoryList );
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCategoriesIncorrectDomainUI
+//
+// Get list of categories
+// Domain ID not valid
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCategoriesIncorrectDomainUIDL( TTestResult& aResult )
+ {
+ // There shall not be categories in domain
+ RCategoryList categoryList;
+ CleanupClosePushL( categoryList );
+ TUid myUid = TUid::Uid(KNonExistingDomainId);
+
+ TInt status = iNotifications->GetCategories( myUid, categoryList );
+
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KErrorDescription, "GetCategories returns with" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status received" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &categoryList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCategoriesMultipleCategories
+//
+// Get list of categories
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCategoriesMultipleCategoriesL( TTestResult& aResult )
+{
+ // There shall be more than one category in domain
+ RCategoryList categoryList;
+ CleanupClosePushL( categoryList );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid my2ndUid = TUid::Uid(KTestUid+1);
+ TUid my3rdUid = TUid::Uid(KTestUid+2);
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps);
+ preStatus = PreconditionRegisterOneEvent( myUid, my2ndUid, KTestEventId, iDefaultVersion, caps);
+ preStatus = PreconditionRegisterOneEvent( myUid, my3rdUid, KTestEventId, iDefaultVersion, caps);
+
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetCategories( myUid, categoryList );
+ if( KErrNone == status )
+ {
+ if( categoryList.Count() > 1 )
+ {
+ _LIT( KErrorDescription, "GetCategories returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of categories found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetCategories returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+
+ status = CleanRegisterOneEvent( myUid, myUid, KTestEventId);
+ status = CleanRegisterOneEvent( myUid, my2ndUid, KTestEventId);
+ status = CleanRegisterOneEvent( myUid, my3rdUid, KTestEventId);
+ if( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test code passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &categoryList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCommands
+//
+// Get list of commands
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCommandsL( TTestResult& aResult )
+ {
+ //There may not be any commands in this category
+ RCommandList commandList;
+ CleanupClosePushL( commandList );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid otherUid = TUid::Uid(KOtherUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, otherUid, KTestEventId, iDefaultVersion, caps);
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetCommands( myUid, otherUid, commandList );
+ if( KErrNone == status )
+ {
+ if( commandList.Count() == 0 )
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of categories found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+
+ status = CleanRegisterOneEvent( myUid, otherUid, KTestEventId );
+ if(KErrNone != status)
+ {
+ _LIT( KErrorDescription, "Cleaning event failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &commandList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCommandsIncorrectDomainUID
+//
+// Get list of commands
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCommandsIncorrectDomainUIDL( TTestResult& aResult )
+ {
+ //There shall not be this domain
+ RCommandList commandList;
+ CleanupClosePushL( commandList );
+ TUid myUid = TUid::Uid(KReallyNonExistingDomainId);
+
+ TInt status = iNotifications->GetCommands( myUid, myUid, commandList );
+ //expected status is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KErrorDescription, "GetCommands returns with expected KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &commandList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCommandsIncorrectCategoryUID
+//
+// Get list of commands
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCommandsIncorrectCategoryUIDL( TTestResult& aResult )
+ {
+ //There shall not be this category
+ RCommandList commandList;
+ CleanupClosePushL( commandList );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid(KReallyNonExistingDomainId);
+
+ TInt status = iNotifications->GetCommands( myUid, invalidUid, commandList );
+ //expected status is KErrMediatorCategoryNotFound
+ if( KErrMediatorCategoryNotFound == status )
+ {
+ _LIT( KErrorDescription, "GetCommands returns with expected KErrMediatorCategoryNotFound" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &commandList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCommands1Command
+//
+// Get list of commands
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCommands1CommandL( TTestResult& aResult )
+ {
+ RCommandList commandList;
+ CleanupClosePushL( commandList );
+ TUid myUid = TUid::Uid(KMinDomainID);
+ TInt status( KErrNone );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+ _LIT( KErrorDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ if( KErrNone == status )
+ {
+ status = iNotifications->GetCommands( myUid, myUid, commandList );
+ if(KErrNone == status )
+ {
+ if(commandList.Count() == 1 )
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of commands found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &commandList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCommandsMultipleCommands
+//
+// Get list of commands
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCommandsMultipleCommandsL( TTestResult& aResult )
+ {
+ RCommandList commandList;
+ CleanupClosePushL(commandList);
+ TUid myUid = TUid::Uid( KTestUid );
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ RCommandList commands;
+ CleanupClosePushL(commands);
+ for ( TInt index = KMinListId; index <KMaxListId; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ User::LeaveIfError( commands.Append(newCommand) );
+ }
+
+ TInt preStatus = PreconditionRegisterCommands( myUid,
+ myUid,
+ commands );
+ _LIT( KDescription, "PreconditionRegisterCommands returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetCommands( myUid, myUid, commandList );
+ if( KErrNone == status )
+ {
+ if( commandList.Count() > 1 )
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of commands found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ status = CleanRegisterCommands( myUid, myUid, commands );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy(&commands);
+ CleanupStack::PopAndDestroy(&commandList);
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfCommandsOver500Commands
+//
+// Get list of commands
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfCommandsOver500CommandsL( TTestResult& aResult )
+ {
+ RCommandList commandList;
+ CleanupClosePushL( commandList );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ RCommandList commands;
+ CleanupClosePushL( commands );
+ for ( TInt index = KMinListId; index <KMinListId+525; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ User::LeaveIfError( commandList.Append(newCommand) );
+ }
+
+ TInt preStatus = PreconditionRegisterCommands( myUid,
+ myUid,
+ commandList );
+ _LIT( KDescription, "PreconditionRegisterCommands returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetCommands( myUid, myUid, commands );
+ if( KErrNone == status )
+ {
+ if( commands.Count() > 500 )
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of commands found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetCommands returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ status = CleanRegisterCommands( myUid, myUid, commandList );
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &commands );
+ CleanupStack::PopAndDestroy( &commandList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfEventsNoEventsInCategory
+//
+// Get list of events
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfEventsNoEventsInCategoryL( TTestResult& aResult )
+ {
+ REventList eventList;
+ REventList eventListB;
+ CleanupClosePushL(eventList);
+ CleanupClosePushL(eventListB);
+
+ TUid myUid = TUid::Uid( KTestUid );
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ RCommandList commands;
+ CleanupClosePushL(commands);
+
+ TInt status = iNotifications->GetEvents( myUid, myUid, eventListB ); // get events
+ status = CleanRegisterMultipleEvents(myUid, myUid, eventListB); // clean those events
+
+ for ( TInt index = KMinListId; index <KMinListId+10; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ User::LeaveIfError( commands.Append(newCommand) );
+ }
+
+ TInt preStatus = PreconditionRegisterCommands( myUid,
+ myUid,
+ commands ); // register some commands
+ _LIT( KDescription, "PreconditionRegisterCommands returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetEvents( myUid, myUid, eventList );
+
+ if( KErrNone == status )
+ {
+ if( eventList.Count() == 0 )
+ {
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ status = CleanRegisterCommands( myUid, myUid, commands );
+ if(KErrNone != status)
+ {
+ _LIT( KDescription, "Test code passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of commands found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ status = CleanRegisterMultipleEvents( myUid, myUid, eventListB ); // clean those events
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &commands );
+ CleanupStack::PopAndDestroy( &eventListB );
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfEventsWithIncorrectDomainUID
+//
+// Get list of events
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfEventsWithIncorrectDomainUIDL( TTestResult& aResult )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ TUid invalidUid = TUid::Uid(KNonExistingDomainId);
+ TUid myUid = TUid::Uid( KTestUid );
+
+ TInt status = iNotifications->GetEvents( invalidUid, myUid, eventList );
+ //expected status is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KErrorDescription, "GetEvents returns with expected KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfEventsWithIncorrectCategoryUID
+//
+// Get list of events
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfEventsWithIncorrectCategoryUIDL( TTestResult& aResult )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ TUid invalidUid = TUid::Uid(KNonExistingDomainId);
+ TUid myUid = TUid::Uid( KTestUid );
+
+ TInt status = iNotifications->GetEvents( myUid, invalidUid, eventList );
+ //expected status is KErrMediatorCategoryNotFound
+ if( KErrMediatorCategoryNotFound == status )
+ {
+ _LIT( KErrorDescription, "GetEvents returns with expected KErrMediatorCategoryNotFound" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfEvents1EventInCategory
+//
+// Get list of events
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfEvents1EventInCategoryL( TTestResult& aResult )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ TUid myUid = TUid::Uid(KTestUid+6);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps);
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetEvents( myUid, myUid, eventList );
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ if( KErrNone == status )
+ {
+ if( eventList.Count() == 1 )
+ {
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of commands found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ aResult.SetResult( status, KErrorDescription );
+ }
+
+ TInt cleanStatus = CleanRegisterOneEvent(myUid, myUid, KTestEventId);
+ if( KErrNone != cleanStatus)
+ {
+ _LIT( KDescription, "Cleaning failed" );
+ aResult.SetResult( cleanStatus, KDescription );
+ }
+ else
+ {
+ aResult.SetResult( cleanStatus, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfEventsMultipleEventsInCategory
+//
+// Get list of events
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::GetListOfEventsMultipleEventsInCategoryL( TTestResult& aResult )
+ {
+ REventList eventList;
+ CleanupClosePushL(eventList);
+ TUid myUid = TUid::Uid( KTestUid );
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList2;
+ CleanupClosePushL(eventList2);
+
+ for( TInt i=80; i<91; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL(newEvent);
+ }
+
+ TInt preStatus = PreconditionRegisterEvents(myUid, myUid, eventList);
+ _LIT( KDescription, "PreconditionRegisterEvents returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetEvents( myUid, myUid, eventList2 );
+
+ if( KErrNone == status )
+ {
+ if( eventList2.Count() > 1 )
+ {
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of events found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ status = CleanRegisterMultipleEvents(myUid, myUid, eventList); // clean those events
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy(&eventList2);
+ CleanupStack::PopAndDestroy(&eventList);
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::GetListOfEventsOver500EventsInCategory
+//
+// Get list of events
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::GetListOfEventsOver500EventsInCategoryL( TTestResult& aResult )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ TUid myUid = TUid::Uid( KTestUid+5 );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList2;
+ CleanupClosePushL( eventList2 );
+
+ for( TInt i=80; i<600; i++) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ TInt preStatus = PreconditionRegisterEvents(myUid, myUid, eventList);
+ _LIT( KDescription, "PreconditionRegisterEvents returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ TInt status = iNotifications->GetEvents( myUid, myUid, eventList2 );
+ if( KErrNone == status )
+ {
+ if( eventList2.Count() == eventList.Count() )
+ {
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ status = CleanRegisterMultipleEvents( myUid, myUid, eventList);
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong amount of commands found" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "GetEvents returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ CleanupStack::PopAndDestroy( &eventList2 );
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiver
+//
+// Subscribe notification receiver
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::SubscribeNotificationReceiver( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ iTestHelper->ClearAllNotifyData();
+ status = iNotifications->RegisterNotificationObserver( iTestHelper );
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KErrorDescription, "RegisterNotificationObserver returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ iTestHelper->ClearAllNotifyData();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::ReSubscribeNotificationReceiver
+// ReSubscribe notification receiver
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::ReSubscribeNotificationReceiver( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ status = iNotifications->RegisterNotificationObserver( iTestHelper );
+
+ //expected status is KErrAlreadyExists
+ if( KErrAlreadyExists == status )
+ {
+ _LIT( KErrorDescription, "RegisterNotificationObserver returns with expected KErrAlreadyExists" );
+ aResult.SetResult( KErrNone, KErrorDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error code" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::UnsubscribeNotificationReceiver
+// unsubscribe notification receiver
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::UnsubscribeNotificationReceiver( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ status = iNotifications->UnregisterNotificationObserver();
+ _LIT( KErrorDescription, "UnsubscribeNotificationReceiver returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::ReUnsubscribeNotificationReceiver
+// ReUnsubscribe notification receiver
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::ReUnsubscribeNotificationReceiver( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ status = iNotifications->UnregisterNotificationObserver();
+
+ //expected return is KErrNotFound
+ if( KErrNotFound == status )
+ {
+ status = KErrNone;
+ }
+ _LIT( KErrorDescription, "UnregisterNotificationObserver returns with" );
+ aResult.SetResult( status, KErrorDescription );
+ CTestScheduler::StartAndStopL( 2000 );
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverRegisterCommands
+// SubscribeNotificationReceiver and Register Commands
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverRegisterCommandsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+ status = iNotifications->RegisterNotificationObserver(iTestHelper);
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "RegisterNotificationObserver returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ KMaxListId+1000,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "RegisterCommand returns with" );
+ aResult.SetResult( status, KDescription );
+ if ( iTestHelper->iNotificationReceived == EClear )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper check failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ iNotifications->UnregisterNotificationObserver();
+ // let request for canceling notications to complete
+ CTestScheduler::StartAndStopL( 2000 );
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverUnregCommands
+// SubscribeNotificationReceiver and unegister Commands
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverUnregCommandsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ RCommandList commands;
+ CleanupClosePushL(commands);
+
+ for ( TInt index = 1; index <KMaxListId; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ User::LeaveIfError( commands.Append(newCommand) );
+ }
+
+ status = iCommandResponder->UnregisterCommand( myUid,
+ myUid,
+ commands );
+
+ _LIT( KDescription, "UnregisterCommand returns with" );
+ aResult.SetResult( status, KDescription );
+ CleanupStack::PopAndDestroy( &commands );
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverUnregCommandsSoThatCatIsEmpty
+// SubscribeNotificationReceiver and unegister commands
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverUnregCommandsSoThatCatIsEmptyL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ RCommandList commandList;
+ CleanupClosePushL( commandList );
+
+ // First clean commands if any exist
+ status = iNotifications->GetCommands( myUid, myUid, commandList );
+ status = CleanRegisterCommands( myUid, myUid, commandList );
+
+ iTestHelper->ClearAllNotifyData();
+ status = iNotifications->RegisterNotificationObserver( iTestHelper );
+ _LIT( KDescription, "RegisterNotificationObserver returns with" );
+ aResult.SetResult( status, KDescription );
+ CTestScheduler::StartAndStopL( 2000 );
+ if( KErrNone == status )
+ {
+ RCommandList commands;
+ CleanupClosePushL(commands);
+
+ for ( TInt index = 1; index <KMaxListId; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ User::LeaveIfError( commands.Append(newCommand) );
+ }
+
+ TInt preStatus = PreconditionRegisterCommands( myUid,
+ myUid,
+ commands );
+ _LIT( KDescription, "PreconditionRegisterCommands register with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iCommandResponder->UnregisterCommand( myUid,
+ myUid,
+ commands );
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "UnregisterCommand returns with" );
+ aResult.SetResult( status, KDescription );
+ }
+ iNotifications->UnregisterNotificationObserver();
+ // let request for canceling notications to complete
+ CTestScheduler::StartAndStopL(2000);
+ CleanupStack::PopAndDestroy(&commands);
+ }
+ CleanupStack::PopAndDestroy(&commandList);
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverRegisterEvents
+// SubscribeNotificationReceiver and Register Events
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverRegisterEventsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ status = iEventProvider->RegisterEvent( myUid,
+ myUid,
+ KTestEventId+10002,
+ iDefaultVersion,
+ caps ) ;
+ CTestScheduler::StartAndStopL(2000);
+ _LIT( KDescription, "RegisterEvent returns with" );
+ aResult.SetResult( status, KDescription );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverUnregisterEvents
+// SubscribeNotificationReceiver and unegister Events
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverUnregisterEventsL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+ status = iNotifications->RegisterNotificationObserver(iTestHelper);
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "RegisterNotificationObserver returns with" );
+ aResult.SetResult( status, KDescription );
+ if( KErrNone == status )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ REventList eventList2;
+ CleanupClosePushL( eventList2 );
+ //clean the allready registered event
+ TInt preStatus = iNotifications->GetEvents( myUid, myUid, eventList );
+ if( KErrNone == preStatus )
+ {
+ preStatus = CleanRegisterMultipleEvents(myUid, myUid, eventList);
+ }
+
+ for( TInt i=76; i<85; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList2.AppendL( newEvent );
+ }
+ preStatus = PreconditionRegisterEvents(myUid, myUid, eventList2);
+ _LIT( KDescription, "PreconditionRegisterEvents returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid,
+ eventList2 );
+ CTestScheduler::StartAndStopL( 3000 );
+ _LIT( KDescription, "UnregisterEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( iTestHelper->iNotificationReceived == 0 )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper check failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ status = iNotifications->UnregisterNotificationObserver();
+ // let request for canceling notications to complete
+ CTestScheduler::StartAndStopL( 2000 );
+ CleanupStack::PopAndDestroy( &eventList2 );
+ CleanupStack::PopAndDestroy( &eventList );
+ }
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverUnregisterEventsSoThatCatIsEmpty
+// SubscribeNotificationReceiver and unegister Events
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverUnregisterEventsSoThatCatIsEmptyL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ REventList eventList;
+ CleanupClosePushL( eventList );
+ REventList eventList2;
+ CleanupClosePushL( eventList2 );
+
+ // Clean events if any exist
+ TInt preStatus = iNotifications->GetEvents( myUid, myUid, eventList );
+ if( KErrNone == preStatus )
+ {
+ preStatus = CleanRegisterMultipleEvents(myUid, myUid, eventList);
+ CTestScheduler::StartAndStopL(2000);
+ }
+
+ iTestHelper->ClearAllNotifyData();
+ status = iNotifications->RegisterNotificationObserver(iTestHelper);
+ CTestScheduler::StartAndStopL( 2000 );
+ if( KErrNone == status )
+ {
+ for( TInt i=85; i<90; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList2.AppendL( newEvent );
+ }
+
+ preStatus = PreconditionRegisterEvents(myUid, myUid, eventList2);
+ _LIT( KDescription, "PreconditionRegisterEvents returns with" );
+ aResult.SetResult( preStatus, KDescription );
+
+ if( KErrNone == preStatus )
+ {
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid, // this category should be empty when these events are unregistered
+ eventList2 );
+
+ CTestScheduler::StartAndStopL(2000);
+ _LIT( KDescription, "UnregisterEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if( iTestHelper->iNotificationReceived == 0 )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper check failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ status = iNotifications->UnregisterNotificationObserver();
+ CTestScheduler::StartAndStopL( 2000 );
+ }
+ CleanupStack::PopAndDestroy( &eventList2 );
+ CleanupStack::PopAndDestroy( &eventList );
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverRegisterCommandsSoThatErrorInRegistration
+// SubscribeNotificationReceiver and Register commands
+//
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverRegisterCommandsSoThatErrorInRegistrationL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ iTestHelper->ClearAllNotifyData();
+ TInt preStatus = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+ if( KErrNone == preStatus )
+ {
+ status = iCommandResponder->RegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+ CTestScheduler::StartAndStopL( 2000 );
+ _LIT( KDescription, "RegisterCommand returns with" );
+ aResult.SetResult( KErrNone, KDescription );
+ if( iTestHelper->iNotificationReceived != 0 )
+ {
+ status = KErrNotFound;
+ _LIT( KDescription, "iTestHelper check failed" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+
+ status = CleanRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId );
+
+ if( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverUnegisterCommandsSoThatErrorInRegistration
+//
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverUnegisterCommandsSoThatErrorInRegistrationL( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TVersion version( 8,5,7 ); // version!
+
+ REventList eventList;
+ CleanupClosePushL(eventList);
+
+ for( TInt i=85; i<90; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = version;
+ newEvent.iCaps = caps;
+ eventList.AppendL(newEvent);
+ }
+
+ // This unregistration should fail!
+ status = iEventProvider->UnregisterEvent( myUid,
+ myUid,
+ eventList );
+ _LIT( KDescription, "UnregisterEvent returns with" );
+ if( KErrNone == status )
+ {
+ status = KErrNotFound;
+ }
+ else
+ {
+ status = KErrNone;
+ }
+ CleanupStack::PopAndDestroy(&eventList);
+ aResult.SetResult( status, KDescription );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverRegisterEventsSoThatErrorInRegistration
+// SubscribeNotificationReceiver and Register Events
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverRegisterEventsSoThatErrorInRegistration( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TVersion version( -1,5,8 );
+
+ iTestHelper->ClearAllNotifyData();
+
+ TInt preStatus = PreconditionRegisterOneEvent( myUid, myUid, KTestEventId, version, caps );
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( preStatus, KErrorDescription );
+
+ if( KErrNone == preStatus )
+ {
+ iTestHelper->ClearAllNotifyData();
+ // This registration fail
+ status = iEventProvider->RegisterEvent( myUid,
+ myUid,
+ KTestEventId,
+ version,
+ caps ) ;
+ if( KErrNone == status )
+ {
+ status = KErrNotFound;
+ }
+ else
+ {
+ status = CleanRegisterOneEvent(myUid, myUid, KTestEventId);
+ if ( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ }
+ _LIT( KDescription, "RegisterEvent test returns with" );
+ aResult.SetResult( status, KDescription ); // return status as test result
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CMediatorTest::SubscribeNotificationReceiverUnregisterEventsSoThatErrorInRegistration
+// UnRegister Events with wrong domainId
+// Expected Behaviour: KErrMediatorDomainNotFound
+// KESKEN
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::SubscribeNotificationReceiverUnregisterEventsSoThatErrorInRegistration( TTestResult& aResult )
+ {
+ TInt status( KErrNone );
+ TUid myUid = TUid::Uid( KTestUid );
+ TUid invalidUid = TUid::Uid( KNonExistingDomainId );
+
+ status = iEventProvider->UnregisterEvent( invalidUid,
+ myUid,
+ KTestEventId ) ;
+ //expected error is KErrMediatorDomainNotFound
+ if( KErrMediatorDomainNotFound == status )
+ {
+ _LIT( KDescription, "UnregisterEvent returns with expected error KErrMediatorDomainNotFound" );
+ aResult.SetResult( KErrNone, KDescription );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Wrong error status" );
+ aResult.SetResult( KErrGeneral, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandCancelAndReissue
+//
+// Test steps:
+// 1) Issues a command
+// 2) Cancels the command
+// 3) Reissues the command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandCancelAndReissueL( TTestResult& aResult )
+ {
+ TUid myUid = TUid::Uid( KTestUid );
+ iTestHelper->ClearAllNotifyData();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ TInt status = PreconditionRegisterCommand( myUid, myUid, KMinListId+2, iDefaultVersion, caps, 5000 );
+
+ if( KErrNone == status )
+ {
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ status = iCommandInitiator->IssueCommand( myUid, myUid, KMinListId+2, iDefaultVersion, *data );
+
+ if ( KErrNone == status )
+ {
+ iCommandInitiator->CancelCommand( myUid, myUid, KMinListId+2 );
+ status = iCommandInitiator->IssueCommand( myUid, myUid, KMinListId+2, iDefaultVersion, *data );
+ CTestScheduler::StartAndStopL(4000);
+ if ( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "2nd issue command failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "1st issue command failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ CleanupStack::PopAndDestroy( data );
+ status = CleanRegisterCommand( myUid, myUid, KMinListId+2 );
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Preconditions failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandCancelAndIssueNewCommand
+//
+// Test steps:
+// 1) Issue a command
+// 2) Cancels the command
+// 3) Issue a new command
+// -----------------------------------------------------------------------------
+//
+
+TInt CMediatorTest::IssueCommandCancelAndIssueNewCommandL( TTestResult& aResult )
+ {
+ TUid myUid = TUid::Uid( KTestUid );
+ iTestHelper->ClearAllNotifyData();
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ const TInt cmdId1 = KMinListId+2;
+ const TInt cmdId2 = KMinListId+3;
+
+ TInt status = PreconditionRegisterCommand( myUid, myUid, cmdId1, iDefaultVersion, caps, 5000 );
+
+ if ( KErrNone == status )
+ {
+ status = PreconditionRegisterCommand( myUid, myUid, cmdId2, iDefaultVersion, caps, 5000 );
+
+ if( KErrNone == status )
+ {
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+ status = iCommandInitiator->IssueCommand( myUid, myUid, cmdId1, iDefaultVersion, *data );
+ CTestScheduler::StartAndStopL(2000);
+ if ( KErrNone == status )
+ {
+ iCommandInitiator->CancelCommand( myUid, myUid, cmdId1 );
+ status = iCommandInitiator->IssueCommand( myUid, myUid, cmdId2, iDefaultVersion, *data );
+ CTestScheduler::StartAndStopL(2000);
+ if ( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "2nd issue command failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else
+ {
+ _LIT( KErrorDescription, "1st issue command failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ //unregister 2nd command
+ status = CleanRegisterCommand( myUid, myUid, cmdId2 );
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Cleaning failed: 2nd command" );
+ aResult.SetResult( status, KDescription );
+ }
+ CleanupStack::PopAndDestroy( data );
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Preconditions failed: 2nd command register" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ //unregister 1st command
+ status = CleanRegisterCommand( myUid, myUid, cmdId1 );
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Cleaning failed: 1st command" );
+ aResult.SetResult( status, KDescription );
+ }
+ CTestScheduler::StartAndStopL(2000);
+ }
+ else
+ {
+ _LIT( KErrorDescription, "Preconditions failed: 1st command register" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::InstantiateAndDeleteMediatorPlugin
+//
+// Test steps:
+// 1) Instantiates the test plugin
+// 2) Destroys the the test plugin
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::InstantiateAndDeleteMediatorPluginL( TTestResult& aResult )
+ {
+ CMediatorPluginBase* testPlugin;
+ TRAPD( status, testPlugin = CMediatorPluginBase::NewL( TUid::Uid(0x87654323 ) ) );
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Failed to create plugin" );
+ aResult.SetResult( status, KDescription );
+ }
+ else
+ {
+ delete testPlugin;
+ _LIT( KErrorDescription, "InstantiateAndDeleteMediatorPlugin test passed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ REComSession::FinalClose();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::IssueCommandNoData
+// A command is issued that does not contain parameter data.
+// Test steps:
+// 1) Issues a command and check for error
+// 2) Issue response and check for error
+// 3) Cleanup
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::IssueCommandNoDataL( TTestResult& aResult )
+ {
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ iTestHelper->ClearAllNotifyData();
+
+ TInt status = PreconditionRegisterCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ caps,
+ KDefaultTimeOut );
+
+ _LIT( KErrorDescription, "PreconditionRegisterCommand returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if( KErrNone == status )
+ {
+ iCommandInitiator->CancelCommand( myUid, myUid, KDefaultCommandId );
+ status = iCommandInitiator->IssueCommand( myUid,
+ myUid,
+ KDefaultCommandId,
+ iDefaultVersion,
+ KNullDesC8 );
+ CTestScheduler::StartAndStopL(2000); // wait 2s
+ _LIT( KErrorDescription, "IssueCommand returns with");
+ aResult.SetResult( status, KErrorDescription );
+
+ if ( KErrNone == status )
+ {
+ status = iCommandResponder->IssueResponse( iTestHelper->iDomain,
+ iTestHelper->iCategory,
+ iTestHelper->iCommandId,
+ KErrNone,
+ KNullDesC8 );
+
+ _LIT( KErrorDescription, "IssueResponse returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if ( KErrNone == status ) // execute cleanup as part of the test
+ {
+ status = CleanRegisterCommand( myUid, myUid, KDefaultCommandId );
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ }
+ else // some step has failed, attempt cleanup but don't care about the result
+ {
+ CleanRegisterCommand( myUid, myUid, KDefaultCommandId );
+ }
+ CTestScheduler::StartAndStopL(1000);
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::InstantiateAndDeleteMediatorPlugin
+// An event is raised that does not contain parameter data.
+// Test steps:
+// 1) Raise an event and check return value
+// 2) cleanup
+// -----------------------------------------------------------------------------
+//
+TInt CMediatorTest::RaiseEventNoDataL( TTestResult& aResult )
+ {
+ TUid myUid = TUid::Uid( KTestUid );
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ TInt status( KErrNone );
+ iTestHelper->ClearAllNotifyData();
+
+ CMediatorEventProvider* eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+ status = eventProvider->RegisterEvent( myUid, myUid, KTestEventId, iDefaultVersion, caps);
+ CTestScheduler::StartAndStopL(1000);
+
+ _LIT( KErrorDescription, "PreconditionRegisterOneEvent returns with" );
+ aResult.SetResult( status, KErrorDescription );
+
+ if( KErrNone == status )
+ {
+ status = eventProvider->RaiseEvent( myUid,
+ myUid,
+ KTestEventId,
+ iDefaultVersion,
+ KNullDesC8 );
+ CTestScheduler::StartAndStopL(2000);
+ _LIT( KDescription, "RaiseEvent returns with" );
+ aResult.SetResult( status, KDescription );
+
+ if ( KErrNone == status ) // execute cleanup as part of the test
+ {
+ status = CleanRegisterOneEvent(myUid, myUid, KTestEventId);
+
+ if ( KErrNone != status )
+ {
+ _LIT( KErrorDescription, "Test passed but cleaning failed" );
+ aResult.SetResult( status, KErrorDescription );
+ }
+ }
+ else // some test step has failed, try to cleanup
+ {
+ CleanRegisterOneEvent( myUid, myUid, KTestEventId );
+ }
+ }
+ CleanupStack::PopAndDestroy( eventProvider );
+ return KErrNone;
+ }
+
+void ResetTestKeys()
+ {
+ RProperty::Set( KMediatorStifTestPsKeys, KCurrentTestListVerificationVerdict, KErrGeneral );
+
+ RProperty::Set( KMediatorStifTestPsKeys, KCurrentTestList, KErrNotSupported ) ;
+
+ TTestItemListSetPckgBuf itemsPckgBuf;
+ itemsPckgBuf().iCount = 0;
+ RProperty::Set( KMediatorStifTestPsKeys, KReceivedTestLists, itemsPckgBuf );
+ }
+
+TInt VerifyTestItemList()
+ {
+ TTestItemListSetPckgBuf itemsPckgBuf;
+ itemsPckgBuf().iCount = 0;
+
+ TInt err = RProperty::Get( KMediatorStifTestPsKeys, KReceivedTestLists, itemsPckgBuf );
+
+ if ( err != KErrNone ) return err;
+
+ TInt listSize( sizeof(TestItemLists) / sizeof(TTestItemList) );
+
+ if ( listSize != itemsPckgBuf().iCount ) return KErrCorrupt;
+
+ TInt verdict( KErrNone );
+
+ for ( TInt i = 0; i < listSize; i++ )
+ {
+ const TTestItemList* registeredDataList = &TestItemLists[i];
+ const TTestItemList* receivedDataList = &( itemsPckgBuf().iTestLists[i]);
+
+ if ( receivedDataList->iDomain != registeredDataList->iDomain ) verdict = KErrCorrupt;
+ if ( receivedDataList->iCategory != registeredDataList->iCategory ) verdict = KErrCorrupt;
+ if ( receivedDataList->iFirst != registeredDataList->iFirst ) verdict = KErrCorrupt;
+ if ( receivedDataList->iLast != registeredDataList->iLast ) verdict = KErrCorrupt;
+ }
+
+ return verdict;
+ }
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterMultipleEventsWithMultipleUIDs
+//
+// Register 50 events in Mediator
+// Expected precondition: No events created previously
+// Expected behaviour: Registration succeed
+// Cleaning: Unregister events
+//
+// Domain: KTestUid
+// Category: KTestUid
+// Event IDs: 50 - 99
+// -----------------------------------------------------------------------------
+//
+void RegisterTestEventListL( TInt aIndex, CMediatorEventProvider& aEventProvider, MediatorService::REventList& aEventList )
+ {
+ if ( aIndex < 0 )User::Leave( KErrCorrupt );
+ if ( aIndex > (sizeof(TestItemLists) / sizeof(TTestItemList) - 1) ) User::Leave( KErrCorrupt );
+
+ User::LeaveIfError( RProperty::Set( KMediatorStifTestPsKeys, KCurrentTestList, aIndex ) );
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ aEventList.Reset();
+
+ const TTestItemList* currentList = &TestItemLists[aIndex];
+
+ for( TInt i = currentList->iFirst; i <= currentList->iLast ; i++ )
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = TVersion();
+ newEvent.iCaps = caps;
+ aEventList.AppendL( newEvent );
+ }
+
+ User::LeaveIfError( aEventProvider.RegisterEvent( currentList->iDomain,
+ currentList->iCategory,
+ aEventList ) );
+
+ }
+
+void CleanTestEventListL( TInt aIndex, CMediatorEventProvider& aEventProvider, REventList& aEventList )
+ {
+ if ( aIndex < 0 )User::Leave( KErrCorrupt );
+ if ( aIndex > (sizeof(TestItemLists) / sizeof(TTestItemList) - 1) ) User::Leave( KErrCorrupt );
+
+ const TTestItemList* currentList = &TestItemLists[aIndex];
+
+ User::LeaveIfError( aEventProvider.UnregisterEvent( currentList->iDomain, currentList->iCategory, aEventList ) );
+
+ }
+
+TInt CMediatorTest::RegisterMultipleEventsWithMultipleUIDsL( TTestResult& aResult )
+ {
+ TInt KTestRounds( sizeof(TestItemLists) / sizeof(TTestItemList) );
+ RArray<REventList*> eventLists;
+ CleanupClosePushL( eventLists );
+ User::LeaveIfError( eventLists.Reserve(KTestRounds) );
+
+ TInt preStatus( KErrNone );
+
+ // reserve space for events
+ for ( TInt i = 0; i < KTestRounds; i++ )
+ {
+ REventList* list = new REventList();
+ if ( list )
+ {
+ User::LeaveIfError( preStatus = eventLists.Append(list) );
+ }
+ else
+ {
+ preStatus = KErrNoMemory;
+ }
+
+ if ( KErrNone != preStatus )
+ {
+ _LIT( KDescription, "Test list initialization failed" );
+ aResult.SetResult( preStatus, KDescription );
+ return KErrNone;
+ }
+ }
+
+ TInt status( KErrNone );
+ for ( TInt i = 0; i < KTestRounds; i++ )
+ {
+ TRAP( status, RegisterTestEventListL( i, *iEventProvider, *eventLists[i] ) );
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Registering events failed" );
+ aResult.SetResult( status, KDescription );
+ return KErrNone;
+ }
+ }
+ CTestScheduler::StartAndStopL( 2000 ); // wait 2s
+ // check results
+ status = VerifyTestItemList();
+
+ if ( KErrNone != status )
+ {
+ _LIT( KDescription, "Data registered to client corrupted" );
+ aResult.SetResult( status, KDescription );
+ }
+
+ for ( TInt i = 0; i < KTestRounds; i++ )
+ {
+ TRAPD( cleanStatus, CleanTestEventListL( i, *iEventProvider, *eventLists[i] ) );
+ eventLists[i]->Reset();
+ if ( KErrNone != cleanStatus )
+ {
+ _LIT( KDescription, "Cleaning event list failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+
+ for ( TInt i = 0; i < eventLists.Count(); i++ )
+ {
+ delete eventLists[i];
+ }
+ CleanupStack::PopAndDestroy( &eventLists );
+ ResetTestKeys();
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMediatorTest::RegisterMultipleCommandsWithMultipleUIDs
+//
+// Expected preconditions: Command does not exist
+// Expected behaviour: Register command succeed
+// Cleaning: Command unregistered
+//
+// Register multiple commands
+// Command ID(s): 1 - KMaxListId
+// -----------------------------------------------------------------------------
+//
+
+void RegisterTestCommandListL( TInt aIndex, CMediatorCommandResponder& aCommandResponder, RCommandList& aCommandList )
+ {
+ if ( aIndex < 0 )User::Leave( KErrCorrupt );
+ if ( aIndex > (sizeof(TestItemLists) / sizeof(TTestItemList) - 1) ) User::Leave( KErrCorrupt );
+
+ User::LeaveIfError( RProperty::Set( KMediatorStifTestPsKeys, KCurrentTestList, aIndex ) );
+
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ aCommandList.Reset();
+
+ const TTestItemList* currentList = &TestItemLists[aIndex];
+
+ for( TInt i = currentList->iFirst; i <= currentList->iLast ; i++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = i;
+ newCommand.iVersion = TVersion();
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KMediatorResponseTimeout;
+ aCommandList.AppendL( newCommand );
+ }
+
+ User::LeaveIfError( aCommandResponder.RegisterCommand( currentList->iDomain,
+ currentList->iCategory,
+ aCommandList ) );
+ }
+
+void CleanTestCommandListL( TInt aIndex, CMediatorCommandResponder& aCommandResponder, RCommandList& aCommandList )
+ {
+ if ( aIndex < 0 )User::Leave( KErrCorrupt );
+ if ( aIndex > (sizeof(TestItemLists) / sizeof(TTestItemList) - 1) ) User::Leave( KErrCorrupt );
+
+ const TTestItemList* currentList = &TestItemLists[aIndex];
+
+ User::LeaveIfError( aCommandResponder.UnregisterCommand( currentList->iDomain, currentList->iCategory, aCommandList ) );
+
+ }
+
+TInt CMediatorTest::RegisterMultipleCommandsWithMultipleUIDsL( TTestResult& aResult )
+ {
+ TInt KTestRounds( sizeof(TestItemLists) / sizeof(TTestItemList) );
+
+ RArray<RCommandList*> commandLists;
+ CleanupClosePushL( commandLists );
+ User::LeaveIfError( commandLists.Reserve(KTestRounds) );
+
+ TInt preStatus( KErrNone );
+ // reserve space for events
+ for( TInt i = 0; i < KTestRounds; i++ )
+ {
+ RCommandList* list = new RCommandList();
+ if ( list )
+ {
+ User::LeaveIfError( preStatus = commandLists.Append(list) );
+ }
+ else
+ {
+ preStatus = KErrNoMemory;
+ }
+ if ( KErrNone != preStatus )
+ {
+ _LIT( KDescription, "Test list initialization failed" );
+ aResult.SetResult( preStatus, KDescription );
+ return KErrNone;
+ }
+ }
+ TInt status( KErrNone );
+ for( TInt i = 0; i < KTestRounds; i++ )
+ {
+ TRAP( status, RegisterTestCommandListL( i, *iCommandResponder, *commandLists[i] ) );
+ if ( KErrNone == status )
+ {
+ if ( status != KErrNone )
+ {
+ _LIT( KDescription, "Receiving end verification failed" );
+ aResult.SetResult( status, KDescription );
+ return KErrNone;
+ }
+ }
+ else
+ {
+ _LIT( KDescription, "Registering commands failed" );
+ aResult.SetResult( status, KDescription );
+ return KErrNone;
+ }
+ }
+ CTestScheduler::StartAndStopL( 2000 ); // wait 2s
+ // check results
+ status = VerifyTestItemList();
+ if( status != KErrNone )
+ {
+ _LIT( KDescription, "Data registered to client corrupted" );
+ aResult.SetResult( status, KDescription );
+ }
+ for( TInt i = 0; i < KTestRounds; i++ )
+ {
+ TRAPD( cleanStatus, CleanTestCommandListL( i, *iCommandResponder, *commandLists[i] ) );
+ commandLists[i]->Reset();
+ if( cleanStatus != KErrNone )
+ {
+ _LIT( KDescription, "Cleaning command list failed" );
+ aResult.SetResult( status, KDescription );
+ }
+ }
+ for( TInt i = 0; i < commandLists.Count(); i++ )
+ {
+ delete commandLists[i];
+ }
+ CleanupStack::PopAndDestroy( &commandLists );
+ ResetTestKeys();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+//Client side OOM test
+// -----------------------------------------------------------------------------
+
+// -----------------------------------------------------------------------------
+// OOM test for Event Consumer
+// -----------------------------------------------------------------------------
+
+
+TInt CMediatorTest::OOMForEventConsumerTestL(TTestResult& aResult)
+ {
+ TInt ret = KErrNoMemory;
+
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailRate);
+ __UHEAP_MARK;
+ TRAP(ret, EventConsumerTestL());
+ __UHEAP_MARKEND;
+ if (ret == KErrNone)
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForEventConsumerTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::EventConsumerTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ CMediatorEventConsumer* eventConsumer;
+ eventConsumer = CMediatorEventConsumer::NewL(iTestHelper);
+ CleanupStack::PushL(eventConsumer);
+ CMediatorEventProvider* eventProvider;
+ eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL(eventProvider);
+
+ status = eventProvider->RegisterEvent(myUid, myUid, KTestEventId,iDefaultVersion, caps);
+
+ if( KErrNone == status || KErrMediatorEventAlreadyExists == status )
+ {
+ status = eventConsumer->SubscribeEvent(myUid, myUid, KTestEventId, iDefaultVersion);
+ User::LeaveIfError(status);
+ if( KErrNone == status )
+ {
+ status = eventConsumer->UnsubscribeEvent(myUid, myUid, KTestEventId);
+ User::LeaveIfError(status);
+ }
+ status = eventProvider->UnregisterEvent(myUid,myUid,KTestEventId);
+ User::LeaveIfError(status);
+ }
+ else
+ {
+ User::LeaveIfError(status);
+ }
+
+ CleanupStack::PopAndDestroy(eventProvider);
+ CleanupStack::PopAndDestroy(eventConsumer);
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// OOM test for Event Provider
+// -----------------------------------------------------------------------------
+
+TInt CMediatorTest::OOMForEventProviderTestL(TTestResult& aResult)
+ {
+ TInt ret = KErrNoMemory;
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailRate);
+ __UHEAP_MARK;
+ TRAP(ret, EventProviderTestL());
+ __UHEAP_MARKEND;
+ if (ret == KErrNone)
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForEventProviderTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::EventProviderTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+
+ CMediatorEventProvider* eventProvider;
+ eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL(eventProvider);
+
+ status = eventProvider->RegisterEvent(myUid, myUid, KTestEventId,iDefaultVersion, caps);
+ //RaiseEvent and Unregister only if event is registerd.
+ if( KErrNone == status || KErrMediatorEventAlreadyExists == status )
+ {
+ status = eventProvider->RaiseEvent(myUid,myUid,KTestEventId,iDefaultVersion,*data);
+ User::LeaveIfError(status);
+ if( KErrNone == status )
+ {
+ status = eventProvider->UnregisterEvent(myUid,myUid,KTestEventId);
+ User::LeaveIfError(status);
+ }
+ }
+ else
+ {
+ User::LeaveIfError(status);
+ }
+ CleanupStack::PopAndDestroy(eventProvider);
+ CleanupStack::PopAndDestroy(data);
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// OOM test for Event provider with list of event
+// -----------------------------------------------------------------------------
+
+TInt CMediatorTest::OOMForEventProviderwithListTestL(TTestResult& aResult)
+ {
+ TInt ret = KErrNoMemory;
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailRate);
+ __UHEAP_MARK;
+ TRAP(ret, EventProviderListEventTestL());
+ __UHEAP_MARKEND;
+ if (ret == KErrNone)
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForEventProviderwithListTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::EventProviderListEventTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ REventList eventList;
+ CleanupClosePushL(eventList);
+ for (TInt i = 1; i < 10; i++) // i = Event ID
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ CMediatorEventProvider* eventProvider;
+ eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL(eventProvider);
+
+ status = eventProvider->RegisterEvent(myUid, myUid, eventList);
+ //Unregister only if event is registerd.
+ if( KErrNone == status || KErrMediatorEventAlreadyExists == status )
+ {
+ status = eventProvider->UnregisterEvent( myUid, myUid, eventList );
+ User::LeaveIfError(status);
+ }
+ else
+ {
+ User::LeaveIfError(status);
+ }
+ CleanupStack::PopAndDestroy(eventProvider);
+ CleanupStack::PopAndDestroy(&eventList);
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// OOM test for Event consumer with list of event
+// -----------------------------------------------------------------------------
+
+TInt CMediatorTest::OOMForEventConsumerWithEventTestL(TTestResult& aResult)
+ {
+ TInt ret = KErrNoMemory;
+
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailRate);
+ __UHEAP_MARK;
+ TRAP(ret, EventConsumerWithEventTestL());
+ __UHEAP_MARKEND;
+ if (ret == KErrNone)
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForEventConsumerWithEventTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::EventConsumerWithEventTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ REventList eventList;
+ CleanupClosePushL(eventList);
+ for (TInt i = 1; i < 10; i++) // i = Event ID
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL(newEvent);
+ }
+ CMediatorEventConsumer* eventConsumer;
+ eventConsumer = CMediatorEventConsumer::NewL(iTestHelper);
+ CleanupStack::PushL(eventConsumer);
+ CMediatorEventProvider* eventProvider;
+ eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+
+ status = eventProvider->RegisterEvent(myUid, myUid, eventList);
+ if( KErrNone == status || KErrMediatorEventAlreadyExists == status )
+ {
+ status = eventConsumer->SubscribeEvent(myUid, myUid, eventList);
+ User::LeaveIfError( status );
+ if( KErrNone == status )
+ {
+ status = eventConsumer->UnsubscribeEvent( myUid, myUid, eventList );
+ User::LeaveIfError( status );
+ }
+ if( KErrNone == status )
+ {
+ status = eventProvider->UnregisterEvent( myUid, myUid, eventList );
+ User::LeaveIfError( status );
+ }
+ }
+ else
+ {
+ User::LeaveIfError(status);
+ }
+
+ CleanupStack::PopAndDestroy(eventProvider);
+ CleanupStack::PopAndDestroy(eventConsumer);
+ CleanupStack::PopAndDestroy(&eventList);
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// OOM test for CommandInitiator
+// -----------------------------------------------------------------------------
+
+TInt CMediatorTest::OOMForCommandInitiatorTestL(TTestResult& aResult)
+ {
+ TInt ret = KErrNoMemory;
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailRate);
+ __UHEAP_MARK;
+ TRAP(ret, CommandInitiatorTestL());
+ __UHEAP_MARKEND;
+ if (ret == KErrNone)
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForCommandInitiatorTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CommandInitiatorTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ _LIT8(KTest, "TestTestTest");
+ HBufC8* data = KTest().AllocLC();
+ CMediatorCommandResponder* commandResponder;
+ commandResponder = CMediatorCommandResponder::NewL( iTestHelper );
+ CleanupStack::PushL(commandResponder);
+
+ CMediatorCommandInitiator* commandInitiator;
+ commandInitiator = CMediatorCommandInitiator::NewL(iTestHelper);
+ CleanupStack::PushL(commandInitiator);
+
+ status = commandResponder->RegisterCommand(myUid, myUid, KDefaultCommandId, iDefaultVersion, caps, KDefaultTimeOut);
+ if( KErrNone == status || KErrMediatorCommandAlreadyExists == status )
+ {
+ status = commandInitiator->IssueCommand(myUid, myUid, KDefaultCommandId, iDefaultVersion, *data);
+ User::LeaveIfError( status );
+ if( KErrNone == status )
+ {
+ _LIT8(KTestResponse, "Command response");
+ HBufC8* replyData = KTestResponse().AllocLC();
+ status = commandResponder->IssueResponse( myUid, myUid, KDefaultCommandId,KErrNone,*replyData );
+ User::LeaveIfError( status );
+ CleanupStack::PopAndDestroy(replyData);
+ }
+ if( KErrNone == status )
+ {
+ status = commandResponder->UnregisterCommand( myUid, myUid, KDefaultCommandId );
+ User::LeaveIfError( status );
+ }
+ }
+ else
+ {
+ User::LeaveIfError(status);
+ }
+
+ CleanupStack::PopAndDestroy(commandInitiator);
+ CleanupStack::PopAndDestroy(commandResponder);
+ CleanupStack::PopAndDestroy(data);
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// OOM test for CommandInitiator with list of commands
+// -----------------------------------------------------------------------------
+
+TInt CMediatorTest::OOMForCommandInitiatorCommandListTestL(TTestResult& aResult)
+ {
+ TInt ret = KErrNoMemory;
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL(RHeap::EDeterministic,allocFailRate);
+ __UHEAP_MARK;
+ TRAP(ret, CommandInitiatorCommandListTestL());
+ __UHEAP_MARKEND;
+ if (ret == KErrNone)
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForCommandInitiatorCommandListTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CommandInitiatorCommandListTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+ //command list
+ RCommandList commandList;
+ CleanupClosePushL(commandList);
+ for ( TInt index = 1; index < 10; index++ )
+ {
+ MediatorService::TCommand newCommand;
+ newCommand.iCommandId = index;
+ newCommand.iVersion = iDefaultVersion;
+ newCommand.iCaps = caps;
+ newCommand.iTimeout = KDefaultTimeOut;
+ commandList.AppendL( newCommand );
+ }
+ CMediatorCommandResponder* commandResponder;
+ commandResponder = CMediatorCommandResponder::NewL( iTestHelper );
+ CleanupStack::PushL(commandResponder);
+
+ status = commandResponder->RegisterCommand(myUid, myUid, commandList);
+ if( KErrNone == status || KErrMediatorCommandAlreadyExists == status )
+ {
+ status = commandResponder->UnregisterCommand( myUid, myUid, commandList );
+ User::LeaveIfError(status);
+ }
+ else
+ {
+ User::LeaveIfError( status );
+ }
+
+ CleanupStack::PopAndDestroy(commandResponder);
+ CleanupStack::PopAndDestroy(&commandList);
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// OOM test for MediatorNotifications
+// -----------------------------------------------------------------------------
+
+TInt CMediatorTest::OOMForMediatorNotificationsTestL( TTestResult& aResult )
+ {
+ TInt ret = KErrNoMemory;
+ for (TInt allocFailRate = 1;; allocFailRate++)
+ {
+ __UHEAP_RESET;
+ __UHEAP_SETFAIL( RHeap::EDeterministic,allocFailRate );
+ __UHEAP_MARK;
+ TRAP(ret, CMediatorNotificationsTestL());
+ __UHEAP_MARKEND;
+ if ( ret == KErrNone )
+ {
+ break;
+ }
+ }
+ __UHEAP_RESET;
+ aResult.SetResult(ret, _L("OOMForMediatorNotificationsTestL"));
+ return KErrNone;
+ }
+
+TInt CMediatorTest::CMediatorNotificationsTestL()
+ {
+ TInt status(KErrNone);
+ TUid myUid = TUid::Uid(KTestUid);
+ TCapabilitySet caps;
+ caps.SetEmpty();
+
+ iTestHelper->ClearAllNotifyData();
+ CMediatorNotifications* notifyMe = CMediatorNotifications::NewL();
+ CleanupStack::PushL( notifyMe );
+ status = notifyMe->RegisterNotificationObserver( iTestHelper );
+ if( KErrNone == status )
+ {
+ REventList eventList;
+ CleanupClosePushL( eventList );
+
+ CMediatorEventProvider* eventProvider;
+ eventProvider = CMediatorEventProvider::NewL();
+ CleanupStack::PushL( eventProvider );
+
+ for( TInt i=0; i<5; i++ ) // Create list of events (i = event ID)
+ {
+ TEvent newEvent;
+ newEvent.iEventId = i;
+ newEvent.iVersion = iDefaultVersion;
+ newEvent.iCaps = caps;
+ eventList.AppendL( newEvent );
+ }
+
+ status = eventProvider->RegisterEvent( myUid, myUid, eventList );
+ if( KErrNoMemory == status )
+ {
+ User::LeaveIfError( status );
+ }
+ CTestScheduler::StartAndStopL( 2000 );
+ status = eventProvider->UnregisterEvent( myUid, myUid, eventList );
+ if( KErrNoMemory == status )
+ {
+ User::LeaveIfError( status );
+ }
+ CleanupStack::PopAndDestroy( eventProvider );
+ CleanupStack::PopAndDestroy( &eventList );
+ }
+ else
+ {
+ User::LeaveIfError( status );
+ }
+ status = notifyMe->UnregisterNotificationObserver();
+ if( KErrNoMemory == status )
+ {
+ User::LeaveIfError( status );
+ }
+ iTestHelper->ClearAllNotifyData();
+ CleanupStack::PopAndDestroy( notifyMe );
+ return status;
+ }
+
+// End of File