// Copyright (c) 2007-2010 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:
// EFM test steps for component testing
//
//
/**
@file
@internalComponent
@test
*/
#include <featmgr/featurecontrol.h>
#include <featmgr/featmgr.h>
#include <featdiscovery.h>
#include "component_test_steps.h"
#include <apgcli.h>
#include <apacmdln.h>
#define THREADS 100
void CNotifierObserver::HandleNotifyChange( TFeatureChangeType, TFeatureEntry )
{
CActiveScheduler::Stop();
}
void CNotifierObserver::HandleNotifyError( TInt )
{
}
CFeatMgrStressTest::CFeatMgrStressTest()
{
SetTestStepName( KFeatMgrStressTest );
}
CFeatMgrStressTest::~CFeatMgrStressTest()
{
//Wait for a second to let test threads die naturally before trying to
//kill them. If the threads are forcefully killed there can be issues
//closing iThreadsArr
User::After(1000000);
// Killing each created thread
for ( TInt i=0; i<iThreadsArr.Count(); ++i)
{
iThreadsArr[i].Kill(1);
}
// Closing the array of threads
iThreadsArr.Close();
// Closing the critical section
iSection.Close();
}
TVerdict CFeatMgrStressTest::doTestStepL()
{
User::LeaveIfError(iSection.CreateLocal());
for(TInt i=0; i<THREADS; i++)
{
TBuf<10> threadName;
threadName.Format(_L("Thread%d"), i);
RThread thread;
TInt err = thread.Create(threadName, CFeatMgrStressTest::ThreadeEntryPoint, KDefaultStackSize, NULL, this);
if( KErrNone != err )
{
User::Panic(_L("Thread could not be created"), err);
}
else
{
User::LeaveIfError(iThreadsArr.Append(thread));
iThreadsArr[i].Resume();
}
}
// To keep the main thread which created the other threads alive untill the test finishes
RSemaphore semaphore;
User::LeaveIfError(semaphore.CreateGlobal(_L("ThreadsSemaphore"), 0));
semaphore.Wait();
TBuf<500> temp;
_LIT(KPostfix, "; ");
for( TInt i=0; i<iThreadsInfoArr.Count(); ++i )
{
TBool testfailed = EFalse;
temp.Format(_L("Thread id = %d: "), iThreadsInfoArr[i].iId);
if( KErrNone != iThreadsInfoArr[i].iStartServerErr )
{
temp.Append(_L("RFeatureControl::Open expects KErrNone, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iStartServerErr);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( KErrNone != iThreadsInfoArr[i].iAddFeatErr )
{
temp.Append(_L("RFeatureControl::AddFeature expects KErrNone, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iAddFeatErr);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( KErrNotFound != iThreadsInfoArr[i].iSetFeatErr )
{
temp.Append(_L("RFeatureControl::SetFeature expects KErrNotFound, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iSetFeatErr);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( KFeatureSupported != iThreadsInfoArr[i].iDetailsFeatErr )
{
temp.Append(_L("RFeatureControl::FeatureSupported expects KFeatureSupported, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iDetailsFeatErr);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( KErrNone != iThreadsInfoArr[i].iDeleteFeatErr )
{
temp.Append(_L("RFeatureControl::DeleteFeature expects KErrNone, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iDeleteFeatErr);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( KErrNone != iThreadsInfoArr[i].iRequestNotif )
{
temp.Append(_L("CFeatureNotifier::NotifyRequest expects KErrNone, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iRequestNotif);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( KErrNone != iThreadsInfoArr[i].iSetFeatNotif )
{
temp.Append(_L("RFeatureControl::SetFeature after notification request expects KErrNone, error value: "));
temp.AppendNum(iThreadsInfoArr[i].iSetFeatNotif);
temp.Append(KPostfix);
testfailed = ETrue;
}
if( testfailed )
{
TESTDIAGNOSTICERROR(EFalse, temp, i);
}
}
return TestStepResult();
}
void CFeatMgrStressTest::DoThreadActionL()
{
TThreadId id = RThread().Id();
TUid uid = {id.Id()};
uid.iUid += 500;
// Create the thread info instance that would hold the results for the tests below
TThreadTestInfo info;
info.iId = uid.iUid;
// A. Create a session to the server
RFeatureControl control;
info.iStartServerErr = control.Open(); // Expected: KErrNone
// B. Adding new feature
TBitFlags32 flags( 0 );
flags.Set( EFeatureSupported );
flags.Set( EFeatureModifiable );
TFeatureEntry newEentry( uid, flags, KDefaultData1 );
info.iAddFeatErr = control.AddFeature( newEentry ); // Expected: KErrNone
// C. Setting an unexisting feature
info.iSetFeatErr = control.SetFeature(KUnknownUid, ETrue, 4); // Expected: KErrNotFound
// D. Requesting feature details
info.iDetailsFeatErr = control.FeatureSupported( uid ); // Expected: KFeatureSupported
// E. Add notification for some feature
// Create an active scheduler
CActiveScheduler* activescheduler = new(ELeave) CActiveScheduler();
CleanupStack::PushL(activescheduler);
// Install the active scheduler
CActiveScheduler::Install(activescheduler);
// Create a notifier
CFeatureNotifier *notif = NULL;
// Creating the notifier observer
CNotifierObserver* pObserver = new(ELeave) CNotifierObserver();
MFeatureObserver* pntr = (MFeatureObserver*)( pObserver );
notif = CFeatureNotifier::NewL(*pntr);
CleanupStack::PushL( notif );
info.iRequestNotif = notif->NotifyRequest( uid ); // Expected: KErrNone
info.iSetFeatNotif = control.SetFeature(uid, KChangeData); // Expected: KErrNone
CActiveScheduler::Start();
CActiveScheduler::Install(NULL);
CleanupStack::PopAndDestroy(2);
// F. Delete added feature
info.iDeleteFeatErr = control.DeleteFeature( uid ); // Expected: KErrNone
// Closing the session to featmgr server
control.Close();
iSection.Wait();
iThreadsInfoArr.Append(info);
if( (++iThreadsCount) == THREADS )
{
RSemaphore semaphore;
User::LeaveIfError(semaphore.OpenGlobal(_L("ThreadsSemaphore")));
semaphore.Signal();
iSection.Signal();
return;
}
iSection.Signal();
}
TInt CFeatMgrStressTest::ThreadeEntryPoint( TAny* aPtrThis)
{
// Creating the cleanup stack for the thread
CTrapCleanup* cleanupStack = CTrapCleanup::New();
TRAPD( err, ((CFeatMgrStressTest*) aPtrThis)->DoThreadActionL() );
__ASSERT_ALWAYS(!err, User::Panic(_L("Thread panic"),err));
// deleting the cleanup stack for the thread
delete cleanupStack;
return 1;
}
CMulticonnectionTestStep1::CMulticonnectionTestStep1()
{
SetTestStepName(KMulticonnectionTest1);
}
TVerdict CMulticonnectionTestStep1::doTestStepL()
{
//Create RFeatureControl object
RFeatureControl control;
TInt err = control.Connect();
CleanupClosePushL( control );
//Create a connection via FeatureManager
TRAP(err, FeatureManager::InitializeLibL());
//request feature information using CFeatureDiscovery class
TBool supported( CFeatureDiscovery::IsFeatureSupportedL(KDefaultSupportedUid) );
TESTDIAGNOSTIC(supported,
_L("Feature state request using FeatureDiscovery failed: the feature is expected to be supported"));
//set feature state using RFeatureControl object
err = control.SetFeature(KDefaultSupportedUid, EFalse, 0);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("Feature state setting failed: error = %d"),err);
//request feature state using FeatureManager
supported = FeatureManager::FeatureSupported( KDefaultSupportedUid.iUid );
TESTDIAGNOSTICERROR(supported==KFeatureUnsupported,
_L("Feature state request using FeatureManager failed, KFeatureUnsupported expected, returned value is = %d"),supported);
//close FeatureManager connection
FeatureManager::UnInitializeLib();
//request feature state using RFeatureControl
supported = control.FeatureSupported( KDefaultSupportedUid );
TESTDIAGNOSTICERROR(supported==KFeatureUnsupported,
_L("Feature state request using FeatureControl failed, KFeatureUnsupported expected, returned value is = %d"),supported);
CleanupStack::PopAndDestroy( &control );
return TestStepResult();
}
CMulticonnectionTestStep2::CMulticonnectionTestStep2()
{
SetTestStepName(KMulticonnectionTest2);
}
TVerdict CMulticonnectionTestStep2::doTestStepL()
{
//request feature information using CFeatureDiscovery class
TBool supported( CFeatureDiscovery::IsFeatureSupportedL(KDefaultUnsupportedUid) );
TESTDIAGNOSTIC(!supported,
_L("Feature state request using FeatureDiscovery failed: the feature is expected to be unsupported"));
supported = CFeatureDiscovery::IsFeatureSupportedL(KModifiableUid);
TESTDIAGNOSTIC(supported,
_L("Feature state request using FeatureDiscovery failed: the feature is expected to be supported"));
supported = CFeatureDiscovery::IsFeatureSupportedL(KUnmodifiableUid);
TESTDIAGNOSTIC(supported,
_L("Feature state request using FeatureDiscovery failed: the feature is expected to be supported"));
supported = CFeatureDiscovery::IsFeatureSupportedL(KUninitializedUid);
TESTDIAGNOSTIC(!supported,
_L("Feature state request using FeatureDiscovery failed: the feature is expected to be unsupported"));
return TestStepResult();
}
CPluginIgnoringTestStep::CPluginIgnoringTestStep()
{
SetTestStepName(KPluginIgnoringTest);
}
TVerdict CPluginIgnoringTestStep::doTestStepL()
{
//first we need to check whether the plugin is present in the plugin foled on the C:-drive
RProcess helperProcess;
TInt err =helperProcess.Create(_L("pluginhelper.exe"),_L("-? c:\\resource\\plugins\\normal_plugin.rsc"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("failed to create helper process, returned value is = %d"),err);
TRequestStatus status;
helperProcess.Rendezvous(status);
helperProcess.Resume();
User::WaitForRequest(status);
if (helperProcess.ExitReason()==KErrNotFound)
{
INFO_PRINTF1(_L("Plugin file was not found in the plugin folder, test is not performed"));
return TestStepResult();
}
RFeatureControl control;
err = control.Connect();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Connect failed, returned value is = %d"),err);
err = control.FeatureSupported( KPluginIgnoringUid );
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("C:-drive based plugin has not been ignored, the feature is expected to be not found, returned value is = %d"),err);
control.Close();
return TestStepResult();
}
CNotificationHandler::CNotificationHandler(TInt aHandlerID, MNotificationOrderVerifier* aNotificationOrderVerifier) :
iNotificationOrderVerifier(aNotificationOrderVerifier),
iID(aHandlerID)
{
}
void CNotificationHandler::HandleNotifyChange( TFeatureChangeType, TFeatureEntry aFeature )
{
iNotificationOrderVerifier->OnNotification(iID, aFeature.FeatureUid().iUid);
}
void CNotificationHandler::HandleNotifyError( TInt /*aError*/ )
{
}
CMultipleNotificationRequestsStep::CMultipleNotificationRequestsStep()
{
SetTestStepName(KMultipleNotificationRequests);
}
TVerdict CMultipleNotificationRequestsStep::doTestStepPreambleL(void)
{
notificationHandler1 = new (ELeave)CNotificationHandler(CNotificationHandler::EHandler1, this);
CleanupStack::PushL( notificationHandler1 );
notificationHandler2 = new (ELeave)CNotificationHandler(CNotificationHandler::EHandler2, this);
CleanupStack::Pop( notificationHandler1 );
return TestStepResult();
}
TVerdict CMultipleNotificationRequestsStep::doTestStepPostambleL(void)
{
delete notificationHandler1;
delete notificationHandler2;
return TestStepResult();
}
TVerdict CMultipleNotificationRequestsStep::doTestStepL()
{
// Install the active scheduler
CActiveScheduler* activescheduler = new(ELeave) CActiveScheduler();
CleanupStack::PushL(activescheduler);
CActiveScheduler::Install(activescheduler);
TInt err = KErrNone;
// Creating notifiers
CFeatureNotifier* notif1 = CFeatureNotifier::NewL(*notificationHandler1);
CleanupStack::PushL( notif1 );
CFeatureNotifier* notif2 = CFeatureNotifier::NewL(*notificationHandler2);
CleanupStack::PushL( notif2 );
TBitFlags32 flags( 0 );
flags.Set( EFeatureSupported);
flags.Set( EFeatureModifiable );
TFeatureEntry entry1( KNewUid1, flags, KDefaultData1 );
TFeatureEntry entry2( KNewUid2, flags, KDefaultData1 );
RFeatureControl control;
err = control.Open();
CleanupClosePushL( control );
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone||err==KErrAlreadyExists,
_L("RFeatureControl::AddFeature failed, returned value is = %d"),err);
err = control.AddFeature(entry2);
TESTDIAGNOSTICERROR(err==KErrNone||err==KErrAlreadyExists,
_L("RFeatureControl::AddFeature failed, returned value is = %d"),err);
err = notif1->NotifyRequest( KNewUid1 );
TESTDIAGNOSTICERROR(err==KErrNone,
_L("CFeatureNotifier::NotifyRequest failed, returned value is = %d"),err);
err = notif2->NotifyRequest( KNewUid2 );
TESTDIAGNOSTICERROR(err==KErrNone,
_L("CFeatureNotifier::NotifyRequest failed, returned value is = %d"),err);
control.SetFeature(KNewUid1, KChangeData);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SetFeature failed, returned value is = %d"),err);
control.SetFeature(KNewUid2, KChangeData);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SetFeature failed, returned value is = %d"),err);
if (TestStepResult() == EFail)
return TestStepResult();
CActiveScheduler::Start();
control.DeleteFeature(KNewUid1);
control.DeleteFeature(KNewUid2);
CleanupStack::PopAndDestroy( &control );
CleanupStack::PopAndDestroy( notif2 );
CleanupStack::PopAndDestroy( notif1 );
CleanupStack::PopAndDestroy( activescheduler );
return TestStepResult();
}
// This function is defined so that CSingleNotificationRequest1 and CSingleNotificationRequest2
// objects are able to print to TEF log files. It was not possible to print from within their
// HandleNotifyChange functions.
void CMultipleNotificationRequestsStep::OnNotification(TInt aHandlerID, TInt aFeatureID)
{
if( aHandlerID == CNotificationHandler::EHandler1 )
{
TESTDIAGNOSTICERROR(aFeatureID == KNewUid1.iUid, _L("CSingleNotificationRequest1::HandleNotifyChange - feature KNewUid1 is expected; feature recevied = %d"), aFeatureID );
}
else if( aHandlerID == CNotificationHandler::EHandler1 )
{
TESTDIAGNOSTICERROR(aFeatureID == KNewUid2.iUid, _L("CSingleNotificationRequest2::HandleNotifyChange - feature KNewUid2 is expected; feature recevied = %d"), aFeatureID );
}
if (++iNotificationCounter == 2)
{
CActiveScheduler::Stop();
}
}
CFeatmgrStartEndInstall::CFeatmgrStartEndInstall()
{
SetTestStepName(KFeatmgrStartEndInstall);
}
TVerdict CFeatmgrStartEndInstall::doTestStepL()
{
RFeatureControl control;
TInt err(KErrNone);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
/*
* General Test Cases
*/
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 1: Calling SWIStart without SWI running
// SWIStart
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 1: Calling SWIStart without SWI running"));
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNotReady,
_L("RFeatureControl::SWIStart expects KErrNotReady; returned value is = %d"),err);
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 2: Call SWIEnd without SWI running
// SWIEnd
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 2: Call SWIEnd without SWI running"));
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNotReady,
_L("RFeatureControl::SWIEnd expects KErrNotReady; returned value is = %d"),err);
control.Close();
// Wait before starting the next test
User::After(100000);
/*
* SWI Installation Test Cases
*/
// Locals for the test scenarios
RApaLsSession ls;
RProcess process;
CApaCommandLine* cmdLine;
TBitFlags32 flags( 0 );
flags.Set( EFeatureSupported);
flags.Set( EFeatureModifiable );
TFeatureEntry entry1( KNewUid1, flags, KDefaultData1 );
TFeatureEntry entry3( KNewUid3, flags, KDefaultData1 );
TFeatureEntry query1(KNewUid1);
TFeatureEntry query3(KNewUid3);
TUint32 data;
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 3: Successful installation and features manipulation
// P&S install -> SWIStart -> SWIEnd -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 3: Successful installation and features manipulation"));
// Launching dummyswi.exe
_LIT(KDummySWIPath, "dummyswi.exe");
err = process.Create(KDummySWIPath, _L("1")); // 1 = install success
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// This delay is used to allow P&S to complete the initial setting of the
// KSAUidSoftwareInstallKeyValue property to ESASwisInstall before we proceed with
// our test case. Otherwise SWIStart will be called before the property is set
// properly and will return KErrNotReady.
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.AddFeature(entry3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// Enable feature
err = control.EnableFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::EnableFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Disable feature
err = control.DisableFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DisableFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Set features
err = control.SetFeature(KNewUid1, ETrue, KChangeData);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SetFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.SetFeature(KNewUid3, KChangeData);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SetFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported before delete expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Delete KNewUid1
err = control.DeleteFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
//
// Check features are supported and retrieve their details BEFORE they are
// committed to the server.
//
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported after delete expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid3; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1500000);
//
// Check features are supported and retrieve their details AFTER they are
// committed in the server.
//
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==KChangeData,
_L("TFeatureEntry::FeatureData expects KChangeData for KNewUid3; returned value is = %d"),data);
// Delete added feature to clean up
err = control.DeleteFeature(KNewUid3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// Check that feature has been really deleted
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
// Resetting
query1 = TFeatureEntry(KNewUid1);
query3 = TFeatureEntry(KNewUid3);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 4: Call to SWIStart without a corresponding call to SWIEnd during installation
// (without time out).
// Also simulates the case of an exe that calls SWIStart but crashes before calling SWIEnd.
// P&S install -> SWIStart -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 4: Call to SWIStart without a corresponding call to SWIEnd during installation (without time out)"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("1"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1300000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 5: Call to SWIStart without a corresponding call to SWIEnd during installation
// (with time out).
// P&S install -> SWIStart -> Time-out -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 5: Call to SWIStart without a corresponding call to SWIEnd during installation (with time out)"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("3")); // 3 = install timed-out
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe
User::After(16300000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 6: Abort SWI install after launched exe makes a call to SWIEnd
// P&S install -> SWIStart -> SWIEnd -> P&S abort
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 6: Abort SWI install after launched exe makes a call to SWIEnd"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("2")); // 2 = install abort
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe
User::After(1500000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 7: Abort SWI install without launched exe making a call to SWIEnd (timed-out)
// P&S install -> SWIStart -> P&S abort -> Time-out
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 7: Abort SWI install without launched exe making a call to SWIEnd (timed-out)"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("2"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe then fire timeout
User::After(16300000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 8: Double call to SWIStart during installation. First call will be effective
// while the second will be ignored and will return KErrInUse.
// It handles as well the case when no features are added between SWIStart and SWIEnd.
// P&S install -> SWIStart -> SWIStart -> SWIEnd -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 8: Double call to SWIStart during installation"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("1"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrInUse,
_L("RFeatureControl::SWIStart expects KErrInUse; returned value is = %d"),err);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1500000);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 9: Call to SWIStart followed by double calls to SWIEnd during installation.
// First call will be effective and second will be ignored and will return KErrNotReady.
// P&S install -> SWIStart -> SWIEnd -> SWIEnd -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 9: Call to SWIStart followed by double calls to SWIEnd during installation"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("1"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNotReady,
_L("RFeatureControl::SWIStart expects KErrNotReady; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe
User::After(1500000);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
/*
* SWI Uninstall Test Cases
*/
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 10: Successful uninstallation and features manipulation
// P&S uninstall -> SWIStart -> SWIEnd -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 10: Successful uninstallation and features manipulation"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("4")); // 4 = uninstall success
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.AddFeature(entry3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// Set features
err = control.SetFeature(KNewUid1, ETrue, KChangeData);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SetFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.SetFeature(KNewUid3, KChangeData);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SetFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported before delete expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Delete KNewUid1
err = control.DeleteFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Check features are supported and retrieve their details BEFORE they are
// committed in the server.
//
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported after delete expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid3; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1500000);
//
// Check features are supported and retrieve their details AFTER they are
// committed in the server.
//
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==KChangeData,
_L("TFeatureEntry::FeatureData expects KChangeData for KNewUid3; returned value is = %d"),data);
// Delete added feature to clean up
err = control.DeleteFeature(KNewUid3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// Making sure feature deleted
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
// Resetting
query1 = TFeatureEntry(KNewUid1);
query3 = TFeatureEntry(KNewUid3);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 11: Call to SWIStart without a corresponding call to SWIEnd during uninstallation
// (without time out).
// Also simulates the case of an exe that calls SWIStart but crashes before calling SWIEnd.
// P&S uninstall -> SWIStart -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 11: Call to SWIStart without a corresponding call to SWIEnd during uninstallation"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("4"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1500000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 12: Call to SWIStart without a corresponding call to SWIEnd during uninstallation
// (with time out).
// P&S uninstall -> SWIStart -> Time-out -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 12: Call to SWIStart without a corresponding call to SWIEnd during uninstallation (with time out)"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("6")); // 6 = uninstall timed-out
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe
User::After(16300000);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 13: Abort SWI uninstall after launched exe makes a call to SWIEnd
// P&S uninstall -> SWIStart -> SWIEnd -> P&S abort
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 13: Abort SWI uninstall after launched exe makes a call to SWIEnd"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("5")); // 5 = Abort uninstall
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe
User::After(1500000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 14: Abort SWI uninstall without launched exe making a call to SWIEnd
// P&S uninstall -> SWIStart -> P&S abort -> Time out
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 14: Abort SWI uninstall without launched exe making a call to SWIEnd"));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("5"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Delay until the P&S property is set to ESASwisStatusAborted in dummyswi.exe then fire timeout
User::After(16300000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
/*
* Simultaneous calls to FeatMgr
*/
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 15: Simultaneous additions to FeatMgr by the launched exe from SWI (after calling
// SWIStart) and by another external exe (helping_exe.exe).
// P&S install -> SWIStart -> AddFeature -> Launch helping_exe ------------> SWIEnd -> P&S success
// | |
// -----> AddFeature ---->
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 15: Simultanuous additions to FeatMgr by the launched exe from SWI (after calling SWIStart) and by another external exe."));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("4"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// KNewUid1 does not exist at this point
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// KNewUid3 added by this exe
err = control.AddFeature(entry3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid3; returned value is = %d"),data);
// Starting helping exe
_LIT(KHelpingExePath, "helping_exe.exe");
err = process.Create(KHelpingExePath, _L("1"));
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KHelpingExePath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Wait for helping_exe to finish
User::After(600000);
// KNewUid1: added by the external exe (helping_exe)
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==KDefaultData1,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// KNewUid3 not commited yet to registry
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid13 returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid3; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1000000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==KDefaultData1,
_L("TFeatureEntry::FeatureData expects KDefaultData1 for KNewUid1; returned value is = %d"),data);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid13 returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==KDefaultData1,
_L("TFeatureEntry::FeatureData expects KDefaultData1 for KNewUid3; returned value is = %d"),data);
//
// Deleting added feature to clean up
//
err = control.DeleteFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Check that feature has been really deleted
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
err = control.DeleteFeature(KNewUid3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// Check that feature has been really deleted
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
// Resetting
query1 = TFeatureEntry(KNewUid1);
query3 = TFeatureEntry(KNewUid3);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 16: A call to SWIStart from this exe and a call to SWIEnd from helping_exe followed
// after that by a call to SWIEnd from this exe.
// P&S install -> SWIStart (exe1) -> Add feature (exe1) -> SWIEnd (exe2) -> SWIEnd (exe1) -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 16: A call to SWIStart from this exe and a call to SWIEnd from helping_exe followed after that by a call to SWIEnd from this exe."));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("1"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding KNewUid1
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
// Starting helping exe which is going to call SWIEnd (passing 2 as a parameter to indicate this)
_LIT(KHelpingExePath, "helping_exe.exe");
err = process.Create(KHelpingExePath, _L("2"));
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KHelpingExePath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
User::After(500000);
// KNewUid1 : will not be committed to registry by the call to SWIEnd from the helping_exe
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1000000);
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==KDefaultData1,
_L("TFeatureEntry::FeatureData expects KDefaultData1 for KNewUid1; returned value is = %d"),data);
// Delete a feature to clean up
err = control.DeleteFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Resetting
query1 = TFeatureEntry(KNewUid1);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
////////////////////////////////////////////////////////////////////////////////////////////
// SCENARIO 17: A call to SWIStart-SWIEnd followed by another call to SWIStart-SWIEnd before
// the SWI successfully finishes. This will work fine and will have the features cached by
// the two tuples. However, it is not a recommended use of the API.
// P&S install -> SWIStart -> SWIEnd -> SWIStart -> SWIEnd -> P&S success
////////////////////////////////////////////////////////////////////////////////////////////
INFO_PRINTF1(_L("SCENARIO 17: A call to SWIStart-SWIEnd followed by another call to SWIStart-SWIEnd."));
// Launching dummyswi.exe
err = process.Create(KDummySWIPath, _L("1"));
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RProcess::Create expects KErrNone, returned value is = %d"),err);
if( err==KErrNone )
{
User::LeaveIfError(ls.Connect());
CleanupClosePushL(ls);
cmdLine = CApaCommandLine::NewLC();
cmdLine->SetExecutableNameL(KDummySWIPath);
cmdLine->SetProcessEnvironmentL(process);
process.Resume();
CleanupStack::PopAndDestroy(2);
cmdLine = NULL;
// Allow P&S to complete initialising
User::After(200000);
err = control.Open();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::Open failed, returned value is = %d"),err);
//
// First SWIStart-SWIEnd call
//
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding feature KNewUid1
err = control.AddFeature(entry1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid1; returned value is = %d"),data);
User::After(200000);
//
// Second SWIStart-SWIEnd call
//
err = control.SWIStart();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIStart expects KErrNone; returned value is = %d"),err);
// Adding features KNewUid3
err = control.AddFeature(entry3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::AddFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid3; returned value is = %d"),data);
err = control.SWIEnd();
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::SWIEnd expects KErrNone; returned value is = %d"),err);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
data = query3.FeatureData();
TESTDIAGNOSTICERROR(data==0,
_L("TFeatureEntry::FeatureData expects 0 for KNewUid3; returned value is = %d"),data);
// Delay until the P&S property is set to ESASwisStatusSuccess in dummyswi.exe to indicate successful installation
User::After(1100000);
// KNewUid1
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid1; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==KDefaultData1,
_L("TFeatureEntry::FeatureData expects KDefaultData1 for KNewUid1; returned value is = %d"),data);
// KNewUid3
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KFeatureSupported,
_L("RFeatureControl::FeatureSupported expects KFeatureSupported for KNewUid3; returned value is = %d"),err);
data = query1.FeatureData();
TESTDIAGNOSTICERROR(data==KDefaultData1,
_L("TFeatureEntry::FeatureData expects KDefaultData1 for KNewUid3; returned value is = %d"),data);
//
// Delete added feature to clean up
//
err = control.DeleteFeature(KNewUid1);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid1; returned value is = %d"),err);
// Check that feature has been really deleted
err = control.FeatureSupported(query1);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid1; returned value is = %d"),err);
err = control.DeleteFeature(KNewUid3);
TESTDIAGNOSTICERROR(err==KErrNone,
_L("RFeatureControl::DeleteFeature expects KErrNone for KNewUid3; returned value is = %d"),err);
// Check that feature has been really deleted
err = control.FeatureSupported(query3);
TESTDIAGNOSTICERROR(err==KErrNotFound,
_L("RFeatureControl::FeatureSupported expects KErrNotFound for KNewUid3; returned value is = %d"),err);
// Resetting
query1 = TFeatureEntry(KNewUid1);
query3 = TFeatureEntry(KNewUid3);
control.Close();
}
process.Close();
// Wait before starting the next test
User::After(100000);
return TestStepResult();
}