//
// Run the tests
//
TVerdict CCmdTestMultipleWait::doTestStepL()
{
CreateDummyDeferredListL();
SsmCommandFactory::DelegateTo(this);
// common BIC tests
__UHEAP_MARK;
TRAPD(err, doTestNewLWithGoodDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestNewLWithBadDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestInternalizeLWithGoodDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestInternalizeLWithBadDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestResourceReaderWithGoodDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestResourceReaderWithMissingDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestResourceReaderWithBadDataL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestCommandTypeL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestCmdFailureIgnoreSeverityL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestCmdFailureHighSeverityL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestCancelCmdIgnoreSeverityL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, doTestCancelCmdHighSeverityL());
TEST(err == KErrNone);
__UHEAP_MARKEND;
return TestStepResult();
}
/** Creates a new setting with a floating-point value.
@param aKey New setting key.
@param aValue Setting value.
@return
KErrNone if successful,
KErrAlreadyExists if a setting with that key already exists
plus other system-wide error codes.
@post
Transactions fail on all error conditions.
Outside transactions: on success the new setting is persistent,
on failure the repository is unmodified.
@capability Dependent Caller must satisfy the write access policy of that key in the repository.
*/
EXPORT_C TInt CRepository::Create(TUint32 aKey, const TReal& aValue)
{
TRAPD(err,iImpl->CreateSettingL(aKey,aValue,NULL));
return err;
}
/** Deletes all the settings that exist and match the specification:
(key & mask) == (partialKey & mask)
Partial key is guaranteed to be masked before use.
Examples of use:
- To delete a single key.
Delete(key, 0xFFFFFFFF, errorKey);
- To delete all keys from 0 to 0xFF:
Delete(0, 0xFFFFFF00, errorKey);
(digits from 0 to 0xFF would be ignored if given in the partial key)
- To delete all keys matching 0x5B??3A?6:
Delete(0x5B003A06, 0xFF00FF0F, errorKey);
@param aPartialKey
Contains a bit pattern that all the keys must at least partially
match.
@param aMask
Has bits set for all the bits in aPartialKey that must match the keys being deleted.
@param aErrorKey If the delete operation fails this contains the key involved in the
failure, or aPartialKey or KUnspecifiedKey if it could not be attributed to any key
@return
KErrNone if successful,
KErrNotFound if no items were found in the partial key range.
plus other system-wide error codes.
@post
Transactions fail on all error conditions except KErrNotFound
Outside transactions: on success the changes are persistent, on failure the
repository is unmodified.
@capability Dependent Caller must satisfy the write policies of all settings found in the
partial key range.
*/
EXPORT_C TInt CRepository::Delete(TUint32 aPartialKey, TUint32 aMask, TUint32& aErrorKey)
{
TRAPD(ret,iImpl->DeleteRangeL(aPartialKey,aMask,aErrorKey));
return ret;
}
// -----------------------------------------------------------------------------
// CDRMHelperServer::CheckPermission().
// This function check timebased contraints for a permission
// -----------------------------------------------------------------------------
//
void CDRMHelperServer::CheckPermission(
CDRMPermission* aPermission ,
const TUint8& aPermType ,
TTimeBased& aTime ,
TTimeIntervalSeconds& aInterval,
const RPointerArray<HBufC8>& aIndividual )
{
#ifdef _DRM_TESTING
TRAPD(err,WriteL(_L8("CheckPermission")));
#endif
CDRMConstraint* c = NULL;
ContentAccess::TIntent type = MapPermissionType(aPermType);
TTime temp;
temp.HomeTime();
TUint32 reason( 0 );
TBool validity = EFalse;
aTime.SetStart(Time::MinTTime());
aTime.SetEnd(Time::MinTTime());
if (aPermission->iAvailableRights & type)
{
c = aPermission->ConstraintForIntent(type);
if (!c)
{
return;
}
if (aPermission->iAvailableRights & ERightsTopLevel)
{
CDRMConstraint* temp = aPermission->TopLevelConstraint();
c->Merge(*temp);
}
validity = c->Valid( temp, aIndividual, reason );
if ( !validity && reason & EConstraintIndividual )
{
return;
}
if (c->iActiveConstraints==EConstraintNone ||
c->iActiveConstraints == EConstraintIndividual )
{
aTime.SetStart(Time::MinTTime());
aTime.SetEnd(Time::MaxTTime());
return;
}
if (c->iActiveConstraints & EConstraintInterval)
{
if (c->iIntervalStart == Time::NullTTime())
{
aInterval = c->iInterval;
}
else
{
aTime.SetStart(c->iIntervalStart);
aTime.SetEnd(c->iIntervalStart + c->iInterval);
}
}
if (c->iActiveConstraints & EConstraintStartTime)
{
if ( !(c->iActiveConstraints & EConstraintInterval ) )
{
aTime.SetStart( c->iStartTime );
if (c->iActiveConstraints&EConstraintEndTime)
{
aTime.SetEnd( c->iEndTime );
}
else
{
aTime.SetEnd( Time::MaxTTime() );
}
}
else
{
aTime.SetStart( aTime.StartTime() > c->iStartTime ? aTime.StartTime() : c->iStartTime );
if (c->iActiveConstraints&EConstraintEndTime)
{
aTime.SetEnd( aTime.EndTime() < c->iEndTime ? aTime.EndTime() : c->iEndTime );
}
}
}
else
{
if (c->iActiveConstraints==EConstraintEndTime)
{
if ( !(c->iActiveConstraints & EConstraintInterval ) )
{
aTime.SetStart(Time::MinTTime());
aTime.SetEnd( c->iEndTime );
}
else
{
aTime.SetEnd( aTime.EndTime() < c->iEndTime ? aTime.EndTime() : c->iEndTime );
}
}
}
}
#ifdef _DRM_TESTING
TRAP(err,WriteL(_L8("Start Time:")));
TRAP(err,WriteTimeL(aTime.StartTime()));
TRAP(err,WriteL(_L8("End Time:")));
TRAP(err,WriteTimeL(aTime.EndTime()));
#endif
}
void CGroupViewTester::HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent)
{
//LOGGING///////////////////////////////////////////////////////////////////////////////////
if(&aView == iLocalView)
test.Printf(_L("LocalView "));
else if(&aView == iGroupViewOne)
test.Printf(_L("GroupViewOne "));
else if(&aView == iGroupViewOneByName)
test.Printf(_L("GroupViewOneByName "));
else if(&aView == iGroupViewOneNotInGroup)
test.Printf(_L("GroupViewOneNotInGroup "));
else if(&aView == iGroupViewUnfiled)
test.Printf(_L("GroupViewUnfiled "));
else
test.Printf(_L("Er, none of the known views... "));
switch (aEvent.iEventType)
{
case TContactViewEvent::EUnavailable:
test.Printf(_L("EUnavailable\n"));
break;
case TContactViewEvent::EReady:
test.Printf(_L("EReady\n"));
break;
case TContactViewEvent::ESortOrderChanged:
test.Printf(_L("ESortOrderChanged\n"));
break;
case TContactViewEvent::ESortError:
test.Printf(_L("ESortError\n"));
break;
case TContactViewEvent::EServerError:
test.Printf(_L("EServerError\n"));
break;
case TContactViewEvent::EIndexingError:
test.Printf(_L("EIndexingError\n"));
break;
case TContactViewEvent::EItemAdded:
test.Printf(_L("EItemAdded\n"));
break;
case TContactViewEvent::EItemRemoved:
test.Printf(_L("EItemRemoved\n"));
break;
case TContactViewEvent::EGroupChanged:
test.Printf(_L("EGroupChanged\n"));
break;
default:
test.Printf(_L("Er, none of the known event types... "));
break;
}
////////////////////////////////////////////////////////////////////////////////////////////
switch (iCurrentTest)
{
case ECreateLocalView:
test(iLocalView==&aView);
test(aEvent.iEventType==TContactViewEvent::EReady);
break;
case EExerciseLocalView:
test(ETrue);
break;
case ECreateGroupOneView:
test(iGroupViewOne==&aView);
test(aEvent.iEventType==TContactViewEvent::EReady);
break;
case ETestGroupOneView:
test(EFalse);
break;
case ECreateGroupOneViewByName:
test(iGroupViewOneByName==&aView);
test(aEvent.iEventType==TContactViewEvent::EReady);
break;
case ETestGroupOneViewByName:
test(EFalse);
break;
case ECreateGroupOneViewNotInGroup:
test(iGroupViewOneNotInGroup==&aView);
test(aEvent.iEventType==TContactViewEvent::EReady);
break;
case ETestGroupOneViewNotInGroup:
test(EFalse);
break;
case EAllViewsOutOfBoundsAccess:
test(EFalse);
break;
case ECreateUnfiledGroupView:
test(iGroupViewUnfiled==&aView);
test(aEvent.iEventType==TContactViewEvent::EReady);
break;
case ETestUnfiledGroupView:
break;
case ETestUnfiledGroupAddition:
{
// No point testing for each and every notification: the test will
// pass for all notifications.
if (iNumNotificationExpected > 1)
{
break;
}
// Test that adding contact which formed part of iGroupViewUnfiled
// to iGroupOne caused update of iGroupViewUnfiled such that the
// contact no longer forms part of iGroupViewUnfiled (i.e. by adding
// the contact to the group it is no longer unfiled is not a member
// of the unfiled view).
TInt ret(KErrNone);
TRAPD(err1, ret = iGroupViewUnfiled->FindL(KNumContacts) );
test(err1 == KErrNone && ret == KErrNotFound);
// Double check - make sure the number of items in the unfiled
// group view agrees with the number of unfiled items reported by
// the database.
TInt groupViewUnfiledCount(0);
TRAPD(err2, groupViewUnfiledCount = iGroupViewUnfiled->CountL() );
CContactIdArray* dbUnfiled = NULL;
TRAPD(err3, dbUnfiled = iDb.UnfiledContactsL() );
test(err2 == KErrNone && err3 == KErrNone && groupViewUnfiledCount==dbUnfiled->Count() );
delete dbUnfiled;
}
break;
case ENumTests:
default:
test(EFalse);
break;
}
if (--iNumNotificationExpected <= 0)
{
iNumNotificationExpected=0;
NextTest();
}
}
//Encrypted Data
TVerdict CTPKCS7EncryptedDataTest::doTestStepL()
{
if (TestStepResult() != EPass)
{
return TestStepResult();
}
TInt reason;
// Read from INI file.
GetIntFromConfig(ConfigSection(),_L("Reason"),reason);
//Is Valid
TBool expectedValid;
TBool checkValid;
checkValid = GetBoolFromConfig(ConfigSection(),_L("IsValid"), expectedValid);
__UHEAP_MARK;
CPKCS7ContentInfo *contentInfo = NULL;
TRAPD (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));
CleanupStack::PushL(contentInfo);
if(err == KErrNone)
{
CPKCS7EncryptedDataObject* p7 = NULL;
TInt type = contentInfo->ContentType();
if( contentInfo->ContentType() == CPKCS7ContentInfo::EContentTypeEncryptedData)
{
TRAPD (err, p7 = CPKCS7EncryptedDataObject::NewL(*contentInfo));
CleanupStack::PushL(p7);
__UHEAP_MARK;
if (checkValid)
{
if(!expectedValid && err == reason)
{
CleanupStack::PopAndDestroy(2,contentInfo);//p7, contentInfo
return TestStepResult();
}
if(!expectedValid && contentInfo->ContentType() == 1)
{
CleanupStack::PopAndDestroy(2,contentInfo);//p7, contentInfo
return TestStepResult();
}
}
if (err != KErrNone)
{
SetTestStepResult(EFail);
ERR_PRINTF2(_L("Got %d building PKCS7 object"), err);
}
//CONTENT TYPE
CPKCS7EncryptedDataObject::TContentType contentType = p7->ContentType();
if(contentType != CPKCS7EncryptedDataObject::EPkcs7Data)
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("ContentType does not match"));
CleanupStack::PopAndDestroy(3,contentInfo);//expectedContentType, p7, contentInfo
return TestStepResult();
}
else
{
INFO_PRINTF1(_L("ContentType matches"));
}
//ENCRYPTEDCONTENT DATA
const TDesC8& contentData = p7->EncryptedContentInfoData();
if(contentData.Compare(*iContentData) != 0)
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("EncryptedContentData does not match"));
CleanupStack::PopAndDestroy(2,contentInfo); //p7, contentInfo
return TestStepResult();
}
else
{
INFO_PRINTF1(_L("EncryptedContentData matches"));
}
//SALT
const CPBEncryptParms& encryptParams = p7->EncryptParams();
if((encryptParams.Salt()).Compare(*iSaltValue) != 0)
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("Salt Value does not match"));
CleanupStack::PopAndDestroy(2, contentInfo);//p7,contentInfo
return TestStepResult();
}
else
{
INFO_PRINTF1(_L("Salt Value matches"));
}
//ITERATION COUNT
TBool checkIteration;
TInt expectedIterationCount;
checkIteration = GetIntFromConfig(ConfigSection(),_L("Iteration"), expectedIterationCount);
if(checkIteration)
{
if(encryptParams.Iterations() != expectedIterationCount)
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("Iterations does not match"));
CleanupStack::PopAndDestroy(2, contentInfo);//p7, contentInfo
return TestStepResult();
}
else
{
INFO_PRINTF1(_L("Iteration matches"));
}
}
//CIPHER
TBool checkCipher;
TPtrC expectedCipher;
TPBECipher cipherValue = (TPBECipher) -1;//assign to impossible value
checkCipher = GetStringFromConfig(ConfigSection(),_L("Algorithm"), expectedCipher);
if(checkCipher)
{
if(expectedCipher.Compare(_L("pbeWithSHA1And40BitRC2_CBC")) == 0)
{
cipherValue = ECipherRC2_CBC_40_5;
}
else if(expectedCipher.Compare(_L("pbeWithSHA1And128BitRC4")) == 0)
{
cipherValue = ECipherARC4_128;
}
else if(expectedCipher.Compare(_L("pbeWithSHA1AndDES-CBC")) == 0)
{
cipherValue = ECipherDES_CBC;
}
else if(expectedCipher.Compare(_L("pbeWithSHAAnd3_KeyTripleDES_CBC")) == 0)
{
cipherValue = ECipher3DES_CBC;
}
else if(expectedCipher.Compare(_L("pbeWithSHAAnd2-KeyTripleDES-CBC"))==0)
{
cipherValue = ECipher2Key3DES_CBC;
}
else if(expectedCipher.Compare(_L("pbeWithSHA1And40BitRC4")) == 0)
{
cipherValue = ECipherARC4_40;
}
else if(expectedCipher.Compare(_L("pbewithSHAAnd128BitRC2CBC")) == 0)
{
cipherValue = ECipherRC2_CBC_128_16;
}
else if(expectedCipher.Compare(_L("pbeWithSHA1AndRC2_CBC")) == 0)
{
cipherValue = ECipherRC2_CBC_40;
}
if(encryptParams.Cipher() != cipherValue)
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("Cipher does not match"));
CleanupStack::PopAndDestroy(3, contentInfo);//expectedCipher,p7,contentInfo
return TestStepResult();
}
else
{
INFO_PRINTF1(_L("Cipher matches"));
}
}
if(contentData.Length() != 0)
{
//Decryption
TBool checkPassword;
TPtrC password;
checkPassword = GetStringFromConfig(ConfigSection(),_L("Password"), password);
if(checkPassword)
{
HBufC8* plainText = p7->DecryptDataL(password);
delete plainText;
SetTestStepResult(EPass);
}
}
CleanupStack::PopAndDestroy(p7);
}
//If ContentType is not Encrypted Data
else
{
if(checkValid)
{
if(!expectedValid && err == reason)
{
CleanupStack::PopAndDestroy(contentInfo);
return TestStepResult();
}
else
{
SetTestStepResult(EFail);
}
}
}
}
else if(err != reason)
{
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(contentInfo);
__UHEAP_MARKEND;
return TestStepResult();
}
// -----------------------------------------------------------------------------
// CSIPProfile::GetParameter
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CSIPProfile::GetParameter(TUint32 aParam, TDesC8 const *& aVal) const
{
switch (aParam)
{
case KSIPProviderName:
{
const TDesC8& val= iSIPProfile->ProviderName();
aVal = &val;
break;
}
case KSIPUserAor:
{
const TDesC8& val = iSIPProfile->AOR();
aVal = &val;
break;
}
case KSIPPrivateIdentity:
{
const TDesC8& val = iSIPProfile->PrivateIdentity();
aVal = &val;
break;
}
case KSIPNegotiatedSecurityMechanism:
{
if(iSIPProfileRegistry)
{
TRAPD(err,iSIPProfileRegistry->NegotiatedSecurityMechanismL(*iSIPProfile));
if (err != KErrNone)
{
return err;
}
}
const TDesC8& val = iSIPProfile->NegotiatedSecurityMechanism();
aVal = &val;
break;
}
case KSIPProfileId:
case KSIPAccessPointId:
case KSIPSigComp:
case KSIPSecurityNegotiation:
case KSIPAutoRegistration:
case KSIPProfileRegistered:
case KSIPRegisteredAors:
case KSIPDefaultProfile:
case KSIPContactHeaderParams:
case KSIPRegistrar:
case KSIPOutboundProxy:
case KSIPDigestUserName:
case KSIPDigestRealm:
case KSIPServerAddress:
case KSIPDigestPassword:
{
return KErrNotFound;
}
default:
{
return iSIPProfile->ExtensionParameter(aParam, aVal);
}
}
return KErrNone;
}
// ----------------------------------------------------------------------------
// CSysApFeatureManager::ConstructL()
// ----------------------------------------------------------------------------
void CSysApFeatureManager::ConstructL()
{
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL()") ) );
FeatureManager::InitializeLibL();
iFeatMgrActive = ETrue;
iSimSupported = FeatureManager::FeatureSupported( KFeatureIdSimCard );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: SIM card supported=%d"), iSimSupported ) );
iOfflineModeSupported = FeatureManager::FeatureSupported( KFeatureIdOfflineMode );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Offline mode supported=%d"), iOfflineModeSupported ) );
iCoverDisplaySupported = FeatureManager::FeatureSupported( KFeatureIdCoverDisplay );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Cover display supported=%d"), iCoverDisplaySupported ) );
iGripNotSupported = FeatureManager::FeatureSupported( KFeatureIdKeypadNoSlider );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: iGripNotSupported=%d"), iGripNotSupported ) );
iLocationPrivacySupported = FeatureManager::FeatureSupported( KFeatureIdPrivacyFramework );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Location Privacy supported=%d"), iLocationPrivacySupported ) );
iMMCSupported = FeatureManager::FeatureSupported( KFeatureIdMmc );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: MMC supported=%d"), iMMCSupported ) );
iMMCHotSwapSupported = FeatureManager::FeatureSupported( KFeatureIdMmcHotswap );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: MMC HotSwap supported=%d"), iMMCHotSwapSupported ) );
iStarterExtensionsSupported = FeatureManager::FeatureSupported( KFeatureIdExtendedStartup );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Starter Extensions supported=%d"), iStarterExtensionsSupported ) );
iCameraSupported = FeatureManager::FeatureSupported( KFeatureIdCamera );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Camera supported=%d"), iCameraSupported ) );
iBtSupported = FeatureManager::FeatureSupported( KFeatureIdBt );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Bluetooth supported=%d"), iBtSupported ) );
iLockSupported = FeatureManager::FeatureSupported( KFeatureIdMmcLock );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Memory card lock supported=%d"), iLockSupported ) );
iEject = FeatureManager::FeatureSupported( KFeatureIdMmcEject );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Memory card sw eject supported=%d"), iEject ) );
iPowerSaveSupported = FeatureManager::FeatureSupported( KFeatureIdPowerSave );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Power save supported=%d"), iPowerSaveSupported ) );
iNoPowerKeySupported = FeatureManager::FeatureSupported( KFeatureIdNoPowerkey );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: No power key supported=%d"), iNoPowerKeySupported ) );
// iFmTxSupported = FeatureManager::FeatureSupported( KFeatureIdFmtx );
// TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: FM TX supported=%d"), iFmTxSupported ) );
// iPenEnabled = AknLayoutUtils::PenEnabled();
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Pen enabled=%d"), iPenEnabled ) );
iVmbxCallDivertIconSupported = FeatureManager::FeatureSupported( KFeatureIdVmbxCallDivertIcon );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: VMBX call divert icon supported=%d"), iVmbxCallDivertIconSupported ) );
iTouchUnlockStrokeSupported = FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke );
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: Touch unlock stroke supported=%d"), iTouchUnlockStrokeSupported ) );
// iFmTxRdsTextSupported = FeatureManager::FeatureSupported( KFeatureIdFfFmtxRdsText );
// TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: FM TX RDS-TEXT supported=%d"), iFmTxRdsTextSupported ) );
CRepository* repository = NULL;
TRAPD( err, repository = CRepository::NewL( KCRUidCoreApplicationUIsConf ) );
if ( err == KErrNone )
{
err = repository->Get( KCoreAppUIsSysAp, iSysApFeatures );
if ( err != KErrNone || iSysApFeatures < 0 ) // ERROR
{
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: ERROR: %d, KCoreAppUIsSysAp=%d"), err, iSysApFeatures ) );
iSysApFeatures = 0;
}
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: KCoreAppUIsSysAp=%d"), iSysApFeatures ) );
err = repository->Get( KCoreAppUIsHotSwapMemoryCardHatch, iHatchSupported );
if ( err != KErrNone || iHatchSupported < 0 ) // ERROR
{
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: ERROR: %d, KCoreAppUIsHotSwapMemoryCardHatch=%d"), err, iHatchSupported ) );
iHatchSupported = EFalse;
}
err = repository->Get( KCoreAppUIsLockedStateLights, iLockedStateLightsSupported );
if ( err != KErrNone || iLockedStateLightsSupported < 0 ) // ERROR
{
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: ERROR: %d, KCoreAppUIsLightsLocked=%d"), err, iLockedStateLightsSupported ) );
iLockedStateLightsSupported = EFalse;
iLockedStateLightsIntensity = KHWRMDefaultIntensity;
}
if ( iLockedStateLightsSupported ) // get intensity only if configuration is supported
{
err = repository->Get( KCoreAppUIsLockedStateLightsIntensity, iLockedStateLightsIntensity );
if ( err != KErrNone || iLockedStateLightsIntensity < KHWRMLightMinIntensity || iLockedStateLightsIntensity > KHWRMLightMaxIntensity )
{
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: ERROR: %d, KCoreAppUIsLightsLockedIntensity=%d"), err, iLockedStateLightsIntensity ) );
iLockedStateLightsIntensity = KHWRMDefaultIntensity;
}
}
}
else
{
TRACES( RDebug::Print( _L("CSysApFeatureManager::ConstructL: open KCRUidCoreApplicatinUIsConf failed, err=%d"), err ) );
}
delete repository;
}
/**
Open a drive for formatting.
*/
TInt FsFormatOpen(CFsRequest* aRequest)
{
TDrive& drive = *aRequest->Drive();
__PRINT1(_L("FsFormatOpen() drv:%d"), drive.DriveNumber());
TInt nMountRes = drive.CheckMount();
//-- KErrNotReady means that there is no file system mounted on this drive
//-- KErrInUse means that there are some "disk access" objects, like RFormat or RRawDisk opened on the mount.
if(nMountRes == KErrNotReady || nMountRes == KErrInUse)
{
__PRINT1(_L("FsFormatOpen() ChkMount:%d"), nMountRes);
return nMountRes;
}
const TFormatMode fmtMode = (TFormatMode)aRequest->Message().Int1();
TName buf;
TUint32 currFsNameHash = 0; //-- current file system name hash, 0 means "not set"; used during forced FS dismounting
if((nMountRes == KErrNone) && drive.CurrentMount().LockStatus() < 0)
{//-- the mount is locked, it has normal objects (files, directories) opened on it.
//-- if someone is interested in the list of opened files and number of opened directories, compile this code in.
#ifdef DUMP_OPENED_OBJECTS
DumpOpenedObjects(drive);
#endif //DUMP_OPENED_OBJECTS
if(!(fmtMode & EForceFormat))
{
__PRINT(_L("FsFormatOpen() The mount is in use"));
return KErrInUse;
}
//-- there is a special flag that tells to force media dismounting even if it has files or dirs opened.
__PRINT(_L("FsFormatOpen() The mount is in use, forcing dismounting!"));
//-- record currently mounted FS name hash, it may be used after forced dismounting
drive.CurrentMount().FileSystemName(buf); //-- the iCurrentMount is alive
currFsNameHash = TVolFormatParam::CalcFSNameHash(buf);
//-- kill the current mount
FsThreadManager::LockDrive(drive.DriveNumber());
TInt nRes = drive.ForceUnmountFileSystemForFormatting();
FsThreadManager::UnlockDrive(drive.DriveNumber());
switch(nRes)
{
case KErrInUse:
__PRINT(_L("FsFormatOpen() The mount has clamps! Can't force dismount"));
return KErrInUse; //-- there are clamps on this drive - can't dismount
case KErrNone:
break;
default:
ASSERT(0); //-- unexpected error code
return nRes;
};
if(fmtMode & EQuickFormat)
{//-- quick format may require the normally mounted FS, make the best effrot to mount it
nMountRes = drive.CheckMount();
}
else
{//-- this will make the FS mounted by force; for full format it will be quicker
nMountRes = KErrCorrupt;
}
}
//-- if True, we will need mount (probably specific) file system by force because normal mounting has failed
TBool bNeedForceMount = (nMountRes != KErrNone);
//-- find out if we have optional data structure that describes format parameter
TUint32 newFsNameHash = 0; //-- file system name hash, may be used for selecting which file system to put onto the volume. 0 means "not specified"
const TLDFormatInfo* pLDFormatInfo = NULL;
const TVolFormatParam* pVolFormatParam = NULL;
__ASSERT_COMPILE(sizeof(TVolFormatParam) >= sizeof(TLDFormatInfo));
TBuf8<sizeof(TVolFormatParam)> paramBuf;
if(fmtMode & ESpecialFormat)
{
//-- the user has provided format parameters structure.
//-- IPC argument #2 contains a structure: <TUint32>[optional package descriptor]
//-- where 1st mandatory TUint32 is a pointer to format counter and the optional additional package is a data structure passed to the filesystem by the client of RFormat
const TInt desLen = aRequest->GetDesLength(KMsgPtr2);
ASSERT((TUint32)desLen >= sizeof(TUint32));
const TInt dataPckgLen = desLen - sizeof(TUint32);
if((TUint32)dataPckgLen > sizeof(TUint32))
{
aRequest->ReadL(KMsgPtr2, paramBuf);
}
if(dataPckgLen == sizeof(TLDFormatInfo))
{//-- the user has provided formatting parameters via TLDFormatInfo structure.
pLDFormatInfo = (const TLDFormatInfo*)(paramBuf.Ptr() + sizeof(TUint32));
}
else if(dataPckgLen == sizeof(TVolFormatParam))
{//-- it's likely to be TVolFormatParam, need to check UId to be sure.
pVolFormatParam = (const TVolFormatParam*)(const TVolFormatParam*)(paramBuf.Ptr() + sizeof(TUint32));
if(pVolFormatParam->iUId == TVolFormatParam::KUId) //-- check the class UID
{//-- this is the real TVolFormatParam object passed
newFsNameHash = pVolFormatParam->FSNameHash();
}
}
else if(dataPckgLen >0)
{//-- parameters data structure has strange length
return KErrArgument;
}
}
//-------------------
if(!newFsNameHash && currFsNameHash)
{//-- new file system name isn't specified (default formatting), but the volume had been forcedly dismounted.
//-- restore the original file system
newFsNameHash = currFsNameHash;
}
if(newFsNameHash)
{//-- check if the specified FS is already mounted on the volume
if(!bNeedForceMount)
{
drive.CurrentMount().FileSystemName(buf); //-- the iCurrentMount is alive
}
else
{ //-- the iCurrentMount can be NULL, use the iFsys - the real file system associated with this drive
buf = drive.GetFSys()->Name();
}
const TUint32 currFSNameHash = TVolFormatParam::CalcFSNameHash(buf);
if(currFSNameHash == newFsNameHash)
{//-- no need to do anything, the required FS is already mounted
newFsNameHash = 0;
}
}
if(newFsNameHash)
{
//-- the user has specified some filesystem to be mounted on the volume. Check if this FS is supported at all.
//-- if it is supported, but some other FS is currently mounted, it will be dismounted and the new one will be forced.
TInt nRes;
for(TInt cntFS=0; ;++cntFS)
{
nRes = drive.FSys().GetSupportedFileSystemName(cntFS, buf); //-- enumerate possible child file systems
if(nRes != KErrNone)
return KErrNotSupported; //-- the filesystem with the given name (fsNameHash) is not supported.
if(newFsNameHash == TVolFormatParam::CalcFSNameHash(buf))
{//-- the filesystem with the given name (fsNameHash) is supported, but some other filesystem can be already mounted
drive.Dismount();
bNeedForceMount = ETrue; //-- this will force the desired FS to be mounted
break;
}
}
}//if(fsNameHash)
//-- try force mounting the desired file system if it is required
if(bNeedForceMount)
{
const TInt KMaxRetries = 3;
for(TInt cnt=0; ; ++cnt)
{
drive.MountFileSystem(ETrue, newFsNameHash);
nMountRes = drive.GetReason();
if(nMountRes == KErrNone || nMountRes == KErrLocked)
break;
drive.Dismount(); //-- will reset mount retries counter
if(cnt >= KMaxRetries)
{
__PRINT1(_L("FsFormatOpen() can't mount FS! res:%d"), nMountRes);
return nMountRes;
}
}
}
ASSERT(nMountRes == KErrNone || nMountRes == KErrLocked);
__ASSERT_DEBUG(drive.CurrentMount().LockStatus()==0, Fault(ESvrFormatOpenFailed));
TDriveInfo dInfo;
drive.DriveInfo(dInfo);
const TInt mediaAtt = dInfo.iMediaAtt;
#if defined(_LOCKABLE_MEDIA)
if (!(fmtMode & EForceErase) && (mediaAtt & KMediaAttLocked))
{
// if attempting to format a locked drive, dismount otherwise subsequent
// requests will operate on a mount that has been forcibly mounted (a few lines above)
CMountCB* pM = &drive.CurrentMount();
if(pM)
pM->Close();
drive.MountFileSystem(EFalse); // clear iCurrentMount
return KErrLocked;
}
#endif
if (!(mediaAtt & KMediaAttFormattable) || (mediaAtt & KMediaAttWriteProtected))
{
CMountCB* pM = &drive.CurrentMount();
if(pM)
pM->Close();
drive.MountFileSystem(EFalse);
return KErrAccessDenied;
}
//-- instantinate and open CFormatCB object for this drive
CFormatCB* formatCB=NULL;
TInt fmtHandle;
TRAPD(ret, formatCB = drive.FormatOpenL(aRequest, fmtHandle, fmtMode, pLDFormatInfo, pVolFormatParam ));
if (ret!=KErrNone)
{
if(formatCB)
formatCB->Close();
return ret;
}
TPtrC8 pH((TUint8*)&fmtHandle,sizeof(TInt));
aRequest->WriteL(KMsgPtr3,pH);
TInt count=100;
TPtrC8 pCount((TUint8*)&count,sizeof(TInt));
aRequest->WriteL(KMsgPtr2,pCount);
aRequest->Session()->IncResourceCount();
return KErrNone;
}
/** Play and record an audio file using the UseOldCodecAudioController
* which uses CMMFCodecs and the 'null' pcm16->pcm16 hw device plugin
* This is for DEF039267
*/
TVerdict CTestMmfAclntOldCodecFile::DoTestStepL( void )
{
INFO_PRINTF1( _L("TestPlayerUtils : File"));
TVerdict ret = EFail;
iError = KErrTimedOut;
TBuf<KSizeBuf> filename;
TPtrC filename1;
if(!GetStringFromConfig(iSectName,iKeyName,filename1))
return EInconclusive;
GetDriveName(filename);
filename.Append(filename1);
TUid useCMMFCodecAudioController;
useCMMFCodecAudioController.iUid = KMmfUidUseOldCodecAudioController;
CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this);
TRAPD(err, recUtil->OpenFileL(filename,useCMMFCodecAudioController));
if (err)
{
INFO_PRINTF2( _L("error opening record to file %d "), err);
}
else
{
CActiveScheduler::Start();
TTimeIntervalMicroSeconds duration = recUtil->Duration();
// Wait for initialisation callback
INFO_PRINTF1( _L("Initialise CMdaAudioPlayerUtility"));
// Check for errors.
if (iError == KErrNone && recUtil != NULL)
{
if(iPlay)
{
iError = KErrTimedOut;
TRAPD(err, recUtil->PlayL());
if (err)
{
INFO_PRINTF2( _L("error opening record to file %d "), err);
}
else
{
//lets time how long the file plays for and check
//it has played for the full time
TTime startTime(0);
TTime endTime(0);
startTime.HomeTime();
// Wait for init callback
CActiveScheduler::Start();
endTime.HomeTime();
//check file played for the expected time - allow margin of error + 1S -0.5S
TTimeIntervalMicroSeconds playduration = endTime.MicroSecondsFrom(startTime);
if ( (playduration.Int64() < (duration.Int64()-KOneSecond/2)) ||
(playduration.Int64() > (duration.Int64()+KOneSecond)) )
{
INFO_PRINTF2(_L("file didn't play for the expected duration expected %ld"), duration.Int64());
INFO_PRINTF2(_L("but actual duration was %ld"), playduration.Int64());
}
else if(iError == KErrNone)
ret = EPass;
}
}
}
recUtil->Close();
}
//now try recording file
TFourCC recordedDataType;
TUid format;
format.iUid = KMmfUidFormatWAVWrite;
//check that the datatype is a valid datatype to record
if (!iKeyName.Compare(_L("ALAW ")))
recordedDataType.Set(KMMFFourCCCodeALAW);
else if (!iKeyName.Compare(_L("PCMU8")))
recordedDataType.Set(KMMFFourCCCodePCMU8);
else if (!iKeyName.Compare(_L("MULAW")))
recordedDataType.Set(KMMFFourCCCodeMuLAW);
else if (!iKeyName.Compare(_L("IMAD")))
recordedDataType.Set(KMMFFourCCCodeIMAD);
else if (!iKeyName.Compare(_L("GSM610")))
recordedDataType.Set(KMMFFourCCCodeGSM610);
//rename file to indicate it is recorded
if (recordedDataType != KMMFFourCCCodeNULL)
{
TInt matchpos = filename.Find(_L(".wav"));//get position of extension
filename.Insert(matchpos,_L("recorded"));//change filename to indicate it is recorded
//delete file prior to recording
RFs fs;
fs.Connect();
fs.Delete(filename);
fs.Close();
TRAPD(err,recUtil->OpenFileL(filename,useCMMFCodecAudioController,useCMMFCodecAudioController,format,recordedDataType));
if (err)
{
ret = EFail;
INFO_PRINTF2( _L("error opening record to file %d "), err);
}
else
{
INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));
CActiveScheduler::Start(); // idle -> open
recUtil->RecordL();
// Commented this line of code as a fix for DEF 40709 as it looks like sending a trace message
// to the TestFramework server(for some reason)and taking a very long time on beech/lubbock
//INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility"));
CActiveScheduler::Start(); // open -> record
User::After(KTwoSeconds);
recUtil->Stop();
TTimeIntervalMicroSeconds expectedDuration(KTwoSeconds);
TTimeIntervalMicroSeconds duration = recUtil->Duration();
//we'll alow +/- 0.5 variance
if (duration > TTimeIntervalMicroSeconds(expectedDuration.Int64() + KDeviation/2))
{
INFO_PRINTF3( _L("Duration too long expected %ld actual %ld "), expectedDuration.Int64(), duration.Int64());
ret = EFail;
}
else if (duration < TTimeIntervalMicroSeconds(expectedDuration.Int64() - KDeviation/2))
{
INFO_PRINTF3( _L("Duration too short expected %ld actual %ld "), expectedDuration.Int64(), duration.Int64());
ret = EFail;
}
recUtil->Close();
}
}
delete recUtil;
User::After(KOneSecond); // wait for deletion to shut down devsound
if(iError != KErrNone)
ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError );
return ret;
}
// ---------------------------------------------------------
// TInt RSCPClient::Connect()
// Creates a new session, and starts the server, if required.
//
// Status : Approved
// ---------------------------------------------------------
//
EXPORT_C TInt RSCPClient::Connect()
{
Dprint( (_L("--> RSCPClient::Connect()") ));
// Use a mutex-object so that two processes cannot start the server at the same time
RMutex startMutex;
TRAPD( errf, FeatureManager::InitializeLibL() );
if( errf != KErrNone )
{
return errf;
}
if(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))
{
isFlagEnabled = ETrue;
}
else
{
isFlagEnabled = EFalse;
}
FeatureManager::UnInitializeLib();
TInt mRet = startMutex.OpenGlobal( KSCPServerName );
if ( mRet == KErrNotFound )
{
mRet = startMutex.CreateGlobal( KSCPServerName );
}
if ( mRet != KErrNone )
{
return mRet;
}
// Acquire the mutex
startMutex.Wait();
TInt retry = KSCPConnectRetries;
TInt r;
for (;;)
{
r = CreateSession( KSCPServerName, Version(), KDefaultMessageSlots );
if ( ( r != KErrNotFound ) && ( r != KErrServerTerminated ) )
{
break;
}
if ( --retry == 0 )
{
break;
}
r = StartServer();
if ( ( r != KErrNone ) && ( r != KErrAlreadyExists ) )
{
break;
}
}
Dprint( (_L("<-- RSCPClient::Connect(), exiting: %d"), r ));
// Release the mutex
startMutex.Signal();
startMutex.Close();
return r;
}
TVerdict CAppFwkStartSafeTestStepProcMonSysRestart::doTestStepL()
{
#ifdef __WINSCW__
ASSERT(0);
#endif
CActiveScheduler* sched = new(ELeave) CActiveScheduler; //lint !e527 Unreachable
CleanupStack::PushL(sched); //lint !e527 Unreachable
CActiveScheduler::Install(sched);
iNotifier = CSaveNotifier::NewL(*this);
CStartSafe* startSafe = CStartSafe::NewL();
CleanupStack::PushL( startSafe );
CStartupProperties* prop = CStartupProperties::NewLC();
prop->SetFileParamsL(KTestProcGood, KNullDesC);
prop->SetStartMethod(EWaitForStart);
prop->SetMonitored(ETrue);
prop->SetRecoveryParams(ERestartOS, 0);
TInt tried;
RProcess proc;
CleanupClosePushL(proc);
TRAPD(err, startSafe->StartAndMonitorL(*prop, proc, tried));
TEST(KErrNone == err);
CleanupStack::Pop(&proc);
CleanupStack::PopAndDestroy(prop);
CleanupStack::PopAndDestroy(startSafe);
INFO_PRINTF1(_L("Process monitoring setup with TRecoveryMethod=ERestartOS"));
proc.Kill(KErrNone);
proc.Close();
TTime init;
init.UniversalTime();
INFO_PRINTF4( _L("Process killed at time %d:%d.%d"), init.DateTime().Minute(), init.DateTime().Second(), init.DateTime().MicroSecond());
INFO_PRINTF1(_L("Starting scheduler (expecting an OS restart)"));
CActiveScheduler::Start(); //Wait for MSaveObserver callback
//resume here after callback has stopped the scheduler
TESTE(iCallbackReceived, iCallbackReceived);
if(iCallbackReceived)
{
const TTimeIntervalMicroSeconds elapsedTime = iShutdownPerformed.MicroSecondsFrom(init);
const TDateTime dt = iShutdownPerformed.DateTime();
const TInt64 value = elapsedTime.Int64();
INFO_PRINTF5(_L("Shutdown callback received at time %d:%d.%d (after %d microseconds)"), dt.Minute(), dt.Second(), dt.MicroSecond(), value);
TESTE((value >= 0) && (value < 1000000), value); // within 1 second
}
else
{
INFO_PRINTF1( _L("Restart didn't take place :-("));
TEST(EFalse);
}
//abort restart
iNotifier->HandleError(KErrNone);
CleanupStack::PopAndDestroy(sched);
return TestStepResult();
}
/**
* CMMFDevSound::CBody::CustomInterface
*
* Returns custom interface proxy object created by Proxy Custom Interface
* Utility.
*
* @param TUid
* UID of the custom interface object to be started.
*
* @return TAny*
* Pointer to the Interface Returned by the DevSoundProxy member.
*/
TAny* CMMFDevSound::CBody::CustomInterface(TUid aInterfaceId)
{
// check if this UID refers to CancelInitialize()
if (aInterfaceId == KMmfUidDevSoundCancelInitializeCustomInterface)
{
MMMFDevSoundCancelInitialize* result = this;
return result;
}
// check if this UID refers to EmptyBuffers()
if (aInterfaceId == KMmfUidDevSoundEmptyBuffersCustomInterface)
{
MMMFDevSoundEmptyBuffers* result = this;
return result;
}
if (aInterfaceId == KMmfUidDevSoundAudioResourceCustomInterface)
{
MAutoPauseResumeSupport* result = this;
return result;
}
if (aInterfaceId == KMmfUidDevSoundTimePlayedCustomInterface)
{
MMMFDevSoundTimePlayed* result = this;
return result;
}
if (aInterfaceId == KMmfUidDevSoundQueryIgnoresUnderflowCustomInterface)
{
MMMFDevSoundQueryIgnoresUnderflow* result = this;
return result;
}
if (aInterfaceId == KMmfUidDevSoundAudioClientThreadInfoCustomInterface)
{
MAudioClientThreadInfo* result = this;
return result;
}
if (aInterfaceId == KMmfUidDevSoundTruePauseCustomInterface)
{
MMMFDevSoundTruePause* result = this;
return result;
}
// first check if we already have resolved a custom interface of this type
TInt index = FindCustomInterface(aInterfaceId);
MMMFDevSoundCustomInterfaceMuxPlugin* ptr = NULL;
// if we found the interface, take a copy of this instead
if (index != KNullHandle)
{
// check our index is valid
ptr = iCustomInterfaceArray[index-1].iInterface;
if (ptr)
{
return ptr->CustomInterface(aInterfaceId);
}
}
else
{
// else try and instantiate a plugin tunnelling
// pair to support this Custom Interface
TRAPD(err, ptr = iMuxUtility->CreateCustomInterfaceMuxL(aInterfaceId));
if (ptr && (err == KErrNone))
{
TMMFDevSoundCustomInterfaceData data;
data.iInterface = ptr;
data.iId = aInterfaceId;
// attempt to open remote demux
// this will store a handle in the mux plugin if successful
// and also return it here - invalid handle = -1
data.iHandle = ptr->OpenInterface(aInterfaceId);
// if the handle is greater than zero then we know we have
// successfully opened the interface
if (data.iHandle > KNullHandle)
{
// append this to the current interface list
TInt err = KErrNone;
err = iCustomInterfaceArray.Append(data);
if (err == KErrNone)
{
// return the custom interface on the ptr
return ptr->CustomInterface(aInterfaceId);
}
}
// no memory or other problem so shut down interface
ptr->Release();
ptr = NULL;
}
}
if (iCIExtension)
{
// CI Extension exists, see if it supports the interface
TAny* interface;
TInt err = iCIExtension->CustomInterfaceExtension(aInterfaceId, interface);
if (err == KErrNone)
{
return interface;
}
}
// No Mux/DeMux support & no support from CI Extension, if here
// So, its not supported
return NULL;
}
/**
* Subroutine performing pre-processing tasks for testexecute execution
* Also, responsible for triggering the state machine through instance of ScriptMaster
* @param aScheduler - Instance of ActiveScheduler created through MainL()
* @param aSysDrive - Default system drive letter to be used for all script parsing
*/
LOCAL_C void ProcessMainL(CActiveScheduler* aScheduler, const TDriveName aSysDrive)
{
TDriveName defaultSysDrive(aSysDrive);
TDriveName testSysDrive(KTEFLegacySysDrive);
TInt waitForLoggingTime = 0;
TBuf<KMaxTestExecuteNameLength> htmlLogPath;
// Create a object of the Parser for TestExecute.ini
CTestExecuteIniData* parseTestExecuteIni = NULL;
TRAPD(err, parseTestExecuteIni = CTestExecuteIniData::NewL(defaultSysDrive));
if (err == KErrNone)
{
CleanupStack::PushL(parseTestExecuteIni);
// Extract all the key values within the object
parseTestExecuteIni->ExtractValuesFromIni();
}
// Read and parse the command line for the flags
// -d -slf -help and -v
TBuf<KMaxTestExecuteCommandLength> commandLine;
TDesC* selTestCfgFileData = NULL; //the pointer to the data of in the .tcs file
ReadCommandLineL(commandLine);
// Make lower case because we parse it for flags and search for ".script"
commandLine.LowerCase();
TBool separateLogFiles(EFalse); // -slf
TBool justInTime(EFalse); // -d
TBool graphicalWindowServer(EFalse); // -gws
TBool helpRequest(EFalse); // -help
TBool versionRequest(EFalse); // -v
TBool includeSelectiveCases(EFalse); // -tci
TBool excludeSelectiveCases(EFalse); // -tcx
TBool pipe(EFalse) ;
// Set up the bools from the command line
ParseCommandLine(commandLine,separateLogFiles,justInTime,graphicalWindowServer,includeSelectiveCases, excludeSelectiveCases,pipe, helpRequest,versionRequest,*parseTestExecuteIni,err);
// If -d then set Just In Time debugging. Panicks break into debug on emulator
(justInTime) ? (User::SetJustInTime(ETrue)) : (User::SetJustInTime(EFalse));
// Hooks for creating the Graphical Window server
#ifdef GWS
#endif
// Create a console
_LIT(KMessage,"TestExecute Script Engine");
CConsoleBase* console = Console::NewL(KMessage,TSize(KConsFullScreen,KConsFullScreen));
CleanupStack::PushL(console);
console->SetCursorHeight(0);
RConsoleLogger consoleLogger(*console);
CScriptControl::iRunScriptFailCount=0;
// A lex for getting the first command line argument, ie the script file path
TLex lex(commandLine);
TPtrC scriptFilePath(lex.NextToken());
TInt ret = KErrNotFound;
if (scriptFilePath.CompareF(KNull) != 0)
{
_LIT(KTEFSwitchPrefix, "-");
if(scriptFilePath.Mid(0,1).CompareF(KTEFSwitchPrefix) == 0)
{
// If the first command line argument is not the script file path but a optional switches
// Then set the script file path for the execution to be 'blank'
scriptFilePath.Set(KNull);
}
else
{
TBuf<KBuffSize> tempScriptPath(scriptFilePath);
// Check whether script name is provided along with folder path in the command line
// If not, take the path from testexecute.ini & name from the command line
ret=scriptFilePath.FindC(KTEFColon);
if(ret==KErrNotFound)
{
if (parseTestExecuteIni != NULL)
{
TBuf<KMaxTestExecuteNameLength> tempBuffer;
parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer);
// If the relative script file path does not refer to the root,
// we will look for DefaultScriptDir entry in testexecute.ini
// If available prepend it to the relative path
// else if the relative path refers to root,
// then set the default system drive, i.e. c:
// else leaving it as it is (considering invalid path)
if (scriptFilePath.Left(1).CompareF(KTEFSlash) != 0 &&
tempBuffer.Length() > 0)
scriptFilePath.Set(tempBuffer);
else if (scriptFilePath.Left(1).CompareF(KTEFSlash) == 0)
scriptFilePath.Set(defaultSysDrive);
else
scriptFilePath.Set(KNull);
}
else
{
// If the file path is not provided in command line as well as in testexecute.ini
// then set the script file path to be 'blank'
scriptFilePath.Set(KNull);
}
// Construct the full file path from the values extracted from command line and ini file
TBuf<KBuffSize> storeScriptPathTemp(scriptFilePath);
storeScriptPathTemp.Append(tempScriptPath);
scriptFilePath.Set(storeScriptPathTemp);
tempScriptPath.Copy(scriptFilePath);
}
//If scriptFilePath is not appended by .script Append .script
if(scriptFilePath.Find(KTEFScriptExtension)==KErrNotFound)
{
tempScriptPath.Append(KTEFScriptExtension);
}
scriptFilePath.Set(tempScriptPath);
}
}
TPtrC pipeName ;
if(pipe)
{
TLex flagLex(commandLine);
//first of all navigate the command line arguments to the selective test cases flag...
while(!flagLex.Eos())
{
TPtrC token(flagLex.NextToken());
if( (token.CompareF(KTestExecuteCommandLineFlagPipe) == 0) )
{
break;
}
}
pipeName.Set(flagLex.NextToken()) ;
}
TSelectiveTestingOptions* selTestingOptions =NULL;
if (includeSelectiveCases && excludeSelectiveCases)
{
//mutually exclusive options have been encountered
includeSelectiveCases =EFalse;
excludeSelectiveCases =EFalse;
console->Printf(KTEFInvalidCommandSetMessage);
console->Printf(KTEFEnterKeyMessage);
console->Getch();
}
else
{
if(includeSelectiveCases || excludeSelectiveCases)
{
RArray<TRange> selectiveCaseRange;
ParseCommandLineForSelectiveTestingOptions(commandLine,*parseTestExecuteIni,selectiveCaseRange, selTestCfgFileData);
//you need to sort these two arrays first, and also if they are both empty ignore the entire option altogether.
if( selectiveCaseRange.Count() > 0 )
{
CleanupStack::PushL(selTestCfgFileData);
TLinearOrder<TRange> orderingrng(TRange::CompareTRangeStartOrder) ;
selectiveCaseRange.Sort(orderingrng );
ESelectiveTesting selectiveTestingType(iExclusive);
if(includeSelectiveCases)
{
selectiveTestingType = iInclusive ;
}
selTestingOptions = new(ELeave) TSelectiveTestingOptions(selectiveCaseRange, selectiveTestingType);
}
else
{
//if no arguments to this option have been found, ignore it...
includeSelectiveCases =EFalse;
excludeSelectiveCases =EFalse;
delete selTestCfgFileData;
}
}
}
if (scriptFilePath.CompareF(KNull)==0)
{
if (!separateLogFiles && !justInTime)
{
// Print the product version details through console window
console->Printf(KTEFVersionMessage);
console->Printf(KTEFProductVersion);
if (!(versionRequest && !helpRequest))
{
// Print the help & usage informations through console window along with product version
console->Printf(KTEFConsoleHelpMessage1);
console->Printf(KTEFConsoleHelpMessage2);
console->Printf(KTEFConsoleHelpMessage3);
console->Printf(KTEFConsoleHelpMessage4);
console->Printf(KTEFConsoleHelpMessage5);
}
}
else
{
// Display a error message on the console window for invalid set of arguments
console->Printf(KTEFInvalidCommandSetMessage);
}
// Exit on a key press from user
console->Printf(KTEFEnterKeyMessage);
console->Getch();
}
else
{
// Create a Interface class object for generating HTML & XML logs
CTestExecuteLogger *tefLogger = new(ELeave) CTestExecuteLogger();
CleanupStack::PushL(tefLogger);
TInt logMode;
TInt logLevel;
TInt remotePanicDetection;
TBuf<KMaxTestExecuteNameLength> iniSysDrive;
if (parseTestExecuteIni != NULL)
{
// Parse ini for retrieving logging options set through ini
parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);
parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);
parseTestExecuteIni->GetKeyValueFromIni(KTEFRemotePanicDetection, remotePanicDetection);
parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultSysDrive, iniSysDrive);
parseTestExecuteIni->GetKeyValueFromIni(KTEFWaitForLoggingTime, waitForLoggingTime);
parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, htmlLogPath);
}
else
{
// Set default values for logging options if parser is not functioning
logMode = TLoggerOptions(ELogHTMLOnly);
logLevel = RFileFlogger::TLogSeverity(ESevrAll);
remotePanicDetection = 0;
iniSysDrive.Copy(KTEFIniSysDrive);
waitForLoggingTime = 5;
htmlLogPath.Copy(KTestExecuteLogPath);
htmlLogPath.Replace(0, 2, defaultSysDrive);
}
tefLogger->SetLoggerOptions(logMode);
if(pipe)
{
tefLogger->SetPipeName(pipeName) ;
}
// Initialise the logging passing in the script file path & log level to the interface
tefLogger->InitialiseLoggingL(scriptFilePath, separateLogFiles, logLevel);
// Check to see if defaultsysdrive key is set in testexecute.ini
// if set to SYSDRIVE, assign the default system drive obtained from the plugin
// else, if a true value is set in testexecute.ini, use it as system drive for all test artifacts
if (iniSysDrive.Length() == 2 && iniSysDrive.Right(1).Compare(KTEFColon) == 0)
testSysDrive.Copy(iniSysDrive);
else if (iniSysDrive.CompareF(KTEFIniSysDrive) == 0)
testSysDrive.Copy(defaultSysDrive);
// Pass the first command line argument to the script master
// which is always the command script
CScriptMaster* scriptMaster = new (ELeave) CScriptMaster(scriptFilePath,*tefLogger, consoleLogger, defaultSysDrive, testSysDrive, selTestingOptions);
// To kick the state machine of the script master off -
// Call the kick method which jumps us into the RunL() of the CScriptMaster class
// CScriptMaster is the top AO in the hierarchy.
scriptMaster->Kick();
// Construct and Install a test watcher object for capturing remote panics during test execution
CTestWatcher* testWatcher = NULL;
if (remotePanicDetection != 0)
{
testWatcher = CTestWatcher::NewL();
testWatcher->StartL();
}
// Enter the Active Scheduler
aScheduler->Start();
// Cleanup
delete scriptMaster;
TInt commentedCommandsCnt=CScriptControl::commentedCommandsCount;
if(commentedCommandsCnt==-1)
{
CScriptControl::commentedCommandsCount=0;
//If the path specified fails check out for path from testexecute.ini
if(ret!=KErrNotFound)
{
//To get scriptFile name i.e get sampleFile.script
TInt posOfLastSlash=scriptFilePath.LocateReverse('\\') ;
scriptFilePath.Set(scriptFilePath.Mid(posOfLastSlash+1));
TBuf<KBuffSize> tempStore(scriptFilePath);
if (parseTestExecuteIni != NULL)
{
TBuf<KMaxTestExecuteNameLength> tempBuffer;
parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer);
if (tempBuffer.CompareF(KNull) != 0)
{
scriptFilePath.Set(tempBuffer);
TBuf<KBuffSize> tempStoreScriptPath(scriptFilePath);
tempStoreScriptPath.Append(tempStore);
scriptFilePath.Set(tempStoreScriptPath);
TBuf<KMaxTestExecuteNameLength> scriptFileLocation(scriptFilePath);
CScriptMaster* scriptMaster = new (ELeave) CScriptMaster(scriptFilePath,*tefLogger, consoleLogger, defaultSysDrive, testSysDrive, selTestingOptions);
// To kick the state machine of the script master off -
// Call the kick method which jumps us into the RunL() of the CScriptMaster class
// CScriptMaster is the top AO in the hierarchy.
scriptMaster->Kick();
// Enter the Active Scheduler
aScheduler->Start();
commentedCommandsCnt=CScriptControl::commentedCommandsCount;
if(commentedCommandsCnt==-1)
{
CScriptControl::commentedCommandsCount=0;
}
// Cleanup
delete scriptMaster;
}
}
}
}
delete selTestingOptions;
TInt commandsCount = CScriptControl::commentedCommandsCount;
TInt countOfRemotePanics = 0;
// Stop and Process the test watcher object for extracting panic informations and print them to the log files
if (remotePanicDetection != 0)
{
testWatcher->Stop();
countOfRemotePanics = testWatcher->iSharedData->iPanicDetails.Count();
if (countOfRemotePanics > 0)
{
tefLogger->LogExtra((TText8*)__FILE__,__LINE__,ESevrErr,
_L("The panic detection thread detected %d panics:"), countOfRemotePanics);
for (TInt count = 0; count < countOfRemotePanics; count++)
tefLogger->LogExtra((TText8*)__FILE__,__LINE__,ESevrErr,_L("Remote Panic %d - Name of Panicked Thread: %S, Exit Reason: %d, Exit Category %S"), count+1, &(testWatcher->iSharedData->iPanicDetails)[count]->iThreadName,(testWatcher->iSharedData->iPanicDetails)[count]->iReason,&(testWatcher->iSharedData->iPanicDetails)[count]->iCategory);
}
delete testWatcher;
}
// Call the Termination routine for logging within the interface
tefLogger->TerminateLoggingL(commandsCount, countOfRemotePanics, CScriptControl::iRunScriptFailCount);
CleanupStack::Pop(tefLogger);
delete tefLogger;
}
if(includeSelectiveCases || excludeSelectiveCases)
{
CleanupStack::PopAndDestroy(selTestCfgFileData);
selTestCfgFileData = NULL;
}
// Close the parser instance if it is active
CleanupStack::PopAndDestroy(console);
if (parseTestExecuteIni != NULL)
{
CleanupStack::PopAndDestroy(parseTestExecuteIni);
}
if (scriptFilePath.CompareF(KNull)!=0)
{
// Wait for flogger to write to file
_LIT(KHtmExtension,".htm");
TParse fileNameParse;
fileNameParse.Set(scriptFilePath, NULL, NULL);
TPtrC fileName = fileNameParse.Name();
htmlLogPath.Append(fileName);
htmlLogPath.Append(KHtmExtension);
#ifdef _DEBUG
RDebug::Print(_L("Log file path--> %S"), &htmlLogPath);
#endif
RFs fs;
fs.Connect();
TBool answer = EFalse;
while(ETrue)
{
TInt err = fs.IsFileOpen(htmlLogPath, answer);
if ((KErrNone==err&&!answer) || KErrNotFound==err || KErrPathNotFound==err)
{
break;
}
User::After(100000);
}
if (waitForLoggingTime > 0)
{
User::After(waitForLoggingTime*1000000);
}
}
}
void CSwiTask::Log(const TDesC& aLine)
{
TRAPD(e,iPassiveLogger->AppendL(aLine));
}
// -----------------------------------------------------------------------------
// AknsDrawUtils::DrawBackground()
// (commented in the header).
// -----------------------------------------------------------------------------
EXPORT_C TBool AknsDrawUtils::DrawBackground( MAknsSkinInstance* aInstance,
MAknsControlContext* aContext, const CCoeControl* aControl,
CBitmapContext& aGc, const TPoint& aDstPos,
const TRect& aControlRect, const TInt aDrawParam )
{
TInt drawParam = aDrawParam;
TInt originalParam = aDrawParam;
TBool retVal = EFalse;
TBool blitFailed = EFalse;
TBool blit = EFalse;
TBool blitAttempted = EFalse;
if ( !&aGc )
{
return retVal;
}
MAknsControlContext* parentContext = GetParentContext( aContext );
if( parentContext )
{
retVal = DrawBackground( aInstance, parentContext, aControl, aGc,
aDstPos, aControlRect, aDrawParam );
drawParam |= KAknsDrawParamNoClearUnderImage;
}
else if( drawParam & KAknsDrawParamBottomLevelRGBOnly )
{
drawParam |= KAknsDrawParamRGBOnly;
}
originalParam = drawParam;
if( aContext )
{
aContext->UpdateContext();
}
TAknsBackground* bgLayout = RetrieveBackgroundLayout( aContext );
TAknsItemID imgIID( KAknsIIDNone );
CAknsImageItemData* imgData = RetrieveBackgroundImage(
aInstance, bgLayout, imgIID );
// chained background
if (imgData && imgData->ParentIID() != KAknsIIDNone)
{
TAknsItemID parentiid = imgData->ParentIID();
TRect parentDrawRect = imgData->DrawRect();
imgData = RetrieveKnownBackgroundImage(
aInstance, parentiid );
if (imgData)
{
imgData->SetDrawRect(parentDrawRect);
drawParam |= KAknsDrawParamChained ;
}
}
TPoint paDelta = GetParentAbsoluteDelta( bgLayout, aControl );
TRect drawRect = aControlRect;
drawRect.Move( aDstPos-aControlRect.iTl );
paDelta += aControlRect.iTl-aDstPos;
if (!(aDrawParam & KAknsDrawParamPrepareOnly))
{
aGc.SetPenStyle(CGraphicsContext::ENullPen);
aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
}
if ( !(aDrawParam & KAknsDrawParamIgnoreLayerMask))
{
if( imgData )
{
blitAttempted = ETrue;
if( (drawParam&KAknsDrawParamNoClearUnderImage)==0 )
{
blit = BlitAndClear( aInstance, aGc, drawRect,
imgData, imgIID, bgLayout, paDelta, drawParam );
}
else
{
blit = Blit( aInstance, aGc, drawRect,
imgData, imgIID, bgLayout, paDelta, drawParam );
}
if ( !blit )
{
blitFailed = ETrue;
}
}
else
{
if( !(drawParam&KAknsDrawParamNoClearUnderImage) &&
!(drawParam&KAknsDrawParamPrepareOnly) )
{
// Clear only if permitted
aGc.DrawRect( drawRect );
}
}
}
if( bgLayout )
{
if (!(aDrawParam & KAknsDrawParamIgnoreLayerMask) && aContext->IsCompatibleWithType(EAknsControlContextTypeMasked))
{
CAknsMaskedLayerBackgroundControlContext* layeredCxt = static_cast<CAknsMaskedLayerBackgroundControlContext*>(aContext);
if (layeredCxt->iOffScreenBmp)
{
CAknsMaskedBitmapItemData* maskedImgData = NULL;
TRAPD( err, maskedImgData = CAknsMaskedBitmapItemData::NewL() );
if ( err != KErrNone )
{
return EFalse;
}
maskedImgData->SetBitmap(layeredCxt->iOffScreenBmp);
maskedImgData->SetMask(layeredCxt->iLayerMask);
TAknsBackground* childLayout = bgLayout->iNext;
blitAttempted = ETrue;
blit = Blit( aInstance, aGc, drawRect, maskedImgData,
KAknsIIDNone, childLayout, paDelta, drawParam );
if ( !blit )
{
blitFailed = ETrue;
}
maskedImgData->SetBitmap(NULL);
maskedImgData->SetMask(NULL);
delete maskedImgData;
if (!(aDrawParam & KAknsDrawParamPrepareOnly))
{
aGc.SetPenStyle(CGraphicsContext::ESolidPen);
aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
}
retVal = !blitFailed;
return retVal;
}
}
if (!aContext->IsCompatibleWithType(EAknsControlContextTypeFrame))
{
// special handling for frames
drawParam|=KAknsDrawParamNoClearUnderImage;
originalParam|=KAknsDrawParamNoClearUnderImage;
}
TAknsBackground* nextLayout = bgLayout->iNext;
while( nextLayout &&
((drawParam & KAknsDrawParamLimitToFirstLevel) == 0) )
{
imgData = RetrieveKnownBackgroundImage( aInstance,
nextLayout->iImageID );
if (imgData && imgData->ParentIID() != KAknsIIDNone)
{
TAknsItemID parentiid = imgData->ParentIID();
TRect parentDrawRect = imgData->DrawRect();
imgData = RetrieveKnownBackgroundImage(
aInstance, parentiid );
if (imgData)
{
imgData->SetDrawRect(parentDrawRect);
drawParam |= KAknsDrawParamChained ;
}
}
else
{
drawParam=originalParam;
}
if( imgData )
{
blitAttempted = ETrue;
blit = BlitAndClear( aInstance, aGc, drawRect, imgData,
nextLayout->iImageID, nextLayout, paDelta, drawParam );
if ( !blit )
{
blitFailed = ETrue;
}
}
nextLayout = nextLayout->iNext;
}
}
if (!(aDrawParam & KAknsDrawParamPrepareOnly))
{
aGc.SetPenStyle(CGraphicsContext::ESolidPen);
aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
}
// If Blit failed, or was not even attempted => return EFalse
if ( blitFailed )
{
retVal = EFalse;
}
else if ( !retVal )
{
retVal = blitAttempted;
}
return retVal;
}
// Step 3 Content
TVerdict CTPKCS7ContentTest::doTestStepL()
{
if (TestStepResult() != EPass)
{
return TestStepResult();
}
TBool checkType;
TBool checkLength;
TBool checkContent;
TInt expectedType;
TInt expectedLength;
TPtrC expectedString;
HBufC8 * expectedContent = NULL;
checkType = GetIntFromConfig (ConfigSection(),_L("ContentType"), expectedType);
checkLength = GetIntFromConfig (ConfigSection(),_L("ContentLength"), expectedLength);
checkContent = GetStringFromConfig(ConfigSection(),_L("ContentString"), expectedString);
if (checkContent)
{
if (expectedString.Length() & 1)
{
SetTestStepResult(ETestSuiteError);
INFO_PRINTF1(_L("ContentString is not a multiple of 2 long"));
checkContent = EFalse;
}
else
{
// workaround to parse the expectedstring
expectedContent = HBufC8::NewLC (expectedString.Length()/2);
TPtr8 des = expectedContent->Des ();
for (TInt i = 0; i < expectedString.Length()/2; i++)
{
TInt top = expectedString[2*i];
TInt low = expectedString[2*i+1];
if (top >= 0x61) top -= (0x61-10);
else top -= 0x30;
if (low >= 0x61) low -= (0x61-10);
else low -= 0x30;
des.Append (top*16+low);
}
}
}
TInt err;
CPKCS7ContentInfo * contentInfo = NULL;
TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));
if(err == KErrNone)
{
CPKCS7SignedObject * p7 = NULL;
if( contentInfo->ContentType() == 2)
{
TRAPD (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));
if (err != KErrNone)
{
SetTestStepResult(EFail);
INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);
}
else
{
CleanupStack::PushL (p7);
const CPKCS7ContentInfo& p7info = p7->ContentInfo ();
if (checkType)
{
if (p7info.ContentType() != expectedType)
{
SetTestStepResult(EFail);
INFO_PRINTF3(_L("Expected ContentType %d, got %d"), expectedType, p7info.ContentType());
}
}
const TDesC8& content = p7info.ContentData();
if (checkLength)
{
if (content.Length() != expectedLength)
{
SetTestStepResult(EFail);
INFO_PRINTF3(_L("Expected ContentLength %d, got %d"), expectedLength, content.Length());
}
}
if (checkContent)
{
if (content.Length() != expectedContent->Length())
{
SetTestStepResult(EFail);
INFO_PRINTF3(_L("Expected ContentString length %d does not correspond to PKCS7 data length %d"),
expectedContent->Length(), content.Length());
}
else
{
if (expectedContent->Compare(content) != 0)
{
SetTestStepResult(EFail);
INFO_PRINTF1(_L("Expected ContentString does not match PKCS7 content"));
}
}
}
CleanupStack::PopAndDestroy (p7);
}
}
}
else
{
SetTestStepResult(EFail);
}
if (expectedContent)
{
CleanupStack::PopAndDestroy (expectedContent);
}
if (!checkType && !checkLength && !checkContent && (TestStepResult()==EPass))
{
SetTestStepResult(EInconclusive);
INFO_PRINTF1(_L("No test performed in this step"));
}
return TestStepResult();
}
void CSimAdaptationObservers::DoGetLastSimEvent(const RMessage2& aMessage)
{
TRAPD(err,aMessage.WriteL(0, iEventPckg));
aMessage.Complete(err);
}
//Digest Info
TVerdict CTPKCS7DigestInfoTest::doTestStepL()
{
if (TestStepResult() != EPass)
{
return TestStepResult();
}
__UHEAP_MARK;
TInt reason;
// Read from INI file.
GetIntFromConfig(ConfigSection(),_L("Reason"),reason);
CPKCS7DigestInfo* p7 = NULL;
TRAPD (err, p7 = CPKCS7DigestInfo::NewL(iRawData->Des()));
CleanupStack::PushL(p7);
if (err != KErrNone)
{
if(err == reason)
{
CleanupStack::PopAndDestroy(p7);
SetTestStepResult(EPass);
return TestStepResult();
}
else
{
SetTestStepResult(EFail);
ERR_PRINTF2(_L("Got %d building PKCS7 object"), err);
}
}
//DIGEST
const TDesC8& digest = p7->Digest();
if(digest.Compare(*iDigest) != 0)
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("Digest does not match"));
}
else
{
INFO_PRINTF1(_L("Digest matches"));
}
//ALGORITHM ID
TBool checkAlgorithm;
TPtrC expectedAlgorithm;
TAlgorithmId algorithmId = (TAlgorithmId) -1;
checkAlgorithm = GetStringFromConfig(ConfigSection(),_L("AlgorithmId"), expectedAlgorithm);
if(checkAlgorithm)
{
if(expectedAlgorithm.Compare(_L("SHA1")) == 0)
{
algorithmId = ESHA1;
}
else if(expectedAlgorithm.Compare(_L("MD5")) == 0)
{
algorithmId = EMD5;
}
if(algorithmId != p7->Algorithm())
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("Algorithm Id does not match"));
}
else
{
INFO_PRINTF1(_L("Algorithm Id matches"));
}
}
//ENCODED PARAMS
const TDesC8& encodedParams= p7->EncodedParams();
if(encodedParams.Length() != 0)
{
if(encodedParams.Compare(*iEncodedParams))
{
SetTestStepResult(EFail);
ERR_PRINTF1(_L("EncodedParams does not match"));
}
else
{
INFO_PRINTF1(_L("EncodedParams match"));
}
}
else if(!iEncodedParams)
{
INFO_PRINTF1(_L("EncodedParams not present"));
}
CleanupStack::PopAndDestroy(p7);
__UHEAP_MARKEND;
return TestStepResult();
}
void CTestAppUi::DoNextEnduranceTestActivation()
{
if (iAutoTestTimer->IsActive())
iAutoTestTimer->Cancel();
TInt rand=0;
if (iDoKills)
{
// Occasionally we kill another TVIEW
TUid killAppUid=KNullUid;
rand=Math::Rand(iRandSeed);
if (rand<=KMaxTInt/8) // 1 in 8 chance
{
killAppUid=KUidViewAppTwo;
}
else if (rand/2<=KMaxTInt/8)
{
killAppUid=KUidViewAppThree;
}
if (killAppUid!=KNullUid)
{
TApaTaskList taskList(CEikonEnv::Static()->WsSession());
TApaTask task=taskList.FindApp(killAppUid);
if (task.Exists())
{
RDebug::Print(_L("TVIEW1 : ********************* KILLING %x ********************* "),killAppUid.iUid);
task.KillTask();
User::After(10000); // 0.1 sec
}
// Start the timer again with a new time delay
TTimeIntervalMicroSeconds32 delay(KMinimumDelay+KMinimumDelay*Math::Rand(iRandSeed)/KMaxTInt);
iAutoTestTimer->Start(delay,delay,TCallBack(EnduranceTestCallBack,this));
TRAPD(err,ActivateViewL(TVwsViewId(killAppUid,KUidViewOne),KUidEndurance,KNullDesC16));
__ASSERT_ALWAYS(!err,User::Panic(_L("ActivateViewL(TVwsViewId(killAppUid,KUidViewOne),KUidEndurance,KNullDesC16)"),err));
return;
}
}
// Otherwise we do another random activation
// Find a new view to activate
TUid viewUid = (Math::Rand(iRandSeed)>KMaxTInt/2) ? KUidViewOne : KUidViewTwo;
TUid appUid = KNullUid;
rand=Math::Rand(iRandSeed);
if (rand<=KMaxTInt/3) // 1 in 3 chance
{
appUid=KUidViewAppOne;
}
else if (rand/2<=KMaxTInt/3)
{
appUid=KUidViewAppTwo;
}
else
{
appUid=KUidViewAppThree;
}
// Decide whether any special condition should be used with activation.
// This can mean the activation will be sluggish, a deactivation will be sluggish
// or the activation will leave or exit
TUid messageUid=KNullUid;
rand=Math::Rand(iRandSeed);
if (rand<KMaxTInt/10) // 1 in 10 chance
{
messageUid=KUidActivationOOM;
}
else if (rand/2<KMaxTInt/10)
{
messageUid=KUidSluggishActivation;
}
else if (rand/3<KMaxTInt/10)
{
STATIC_CAST(CTestView*,View(VIEW_ONE))->iSluggishDeactivation=ETrue;
}
else if (rand/4<=KMaxTInt/10 && iDoKills)
{
STATIC_CAST(CTestView*,View(VIEW_ONE))->iExitDeactivation=ETrue;
}
else if (rand<=KMaxTInt && iDoKills && appUid==KUidViewAppTwo)
{
messageUid=KUidActivationExit;
}
// Start the timer again with a new time delay
TTimeIntervalMicroSeconds32 delay(KMinimumDelay+KMinimumDelay*Math::Rand(iRandSeed)/KMaxTInt);
iAutoTestTimer->Start(delay,delay,TCallBack(EnduranceTestCallBack,this));
TRAPD(err,ActivateViewL(TVwsViewId(appUid,viewUid),messageUid,KNullDesC));
__ASSERT_ALWAYS(!err,User::Panic(_L("ActivateViewL(TVwsViewId(appUid,viewUid),messageUid,KNullDesC)"),err));
}
// -----------------------------------------------------------------------------
// CDRMHelperServer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CDRMHelperServer::ConstructL()
{
TInt err = 0;
#ifdef _DRM_TESTING
TRAPD( r , WriteL(_L8("ConstructL")) );
#endif
TUint8 waitCount = 0;
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iDrm.StartServer());
User::LeaveIfError(iDrm.Connect());
StartL(KDRMHelperServerName);
//ignore errors
err = User::RenameProcess( KDRMHSServerFileName );
err = User::RenameThread(KDRMHSServerFileName);
CreatePrivatePathL(iFs); // create path for internal data file
iEndTimeFactory = CEndTimeFactory::NewL( *this );
err = KErrNotFound;
while( err!=0 && waitCount < 30 ) // wait maximum of 6s
{
TRAP( err , iNotifier = CDRMNotifier::NewL() );
if ( err ) // wait only if the server isn't running
{
User::After(200000); // 0.2s
waitCount++;
}
if (iNotifier)
{
iNotifier->RegisterEventObserverL( *this , KEventTimeChange );
}
}
#ifdef _DRM_TESTING
TRAP( r , WriteL(_L8("ConstructL->Notifier")) );
#endif
User::LeaveIfError( err ); // None can do, throw an exception.
iUiTimeNotifier = CEnvironmentChangeNotifier::NewL(
EPriorityHigh,
TCallBack(UiTimeChanged,this)
);
iUiTimeNotifier->Start();
iIdleObserver = CIdleObserver::NewL( *this );
iIdleObserver->StartL();
#ifdef _DRM_TESTING
TRAP( r , WriteL(_L8("ConstructL->IdleObserver")) );
#endif
CreateCRKeyL();
RestoreL();
iEndTimeFactory->HandleExpiredL();
#ifdef _DRM_TESTING
TRAP( r , WriteL(_L8("ConstructL->End")) );
#endif
}
/**
Function : doTestStepL
Description : Sets the priority of an email message via the IMAP \Flagged flag
@return : TVerdict - Test step result
*/
TVerdict CT_MsgSetImap4EmailPriority::doTestStepL()
{
INFO_PRINTF1( _L("Test Step : SetSmtpEmailPriority") );
if (ReadIni())
{
TMsvId parentFolderId;
// Local parent folder location...
if(iLocation.Compare(_L("LOCAL"))==0)
{
// Retrieves the folder Id based on the local folder name read from the ini file
parentFolderId = CT_MsgUtilsEnumConverter::FindFolderIdByName(iParentFolderName);
if(parentFolderId == KErrNotFound)
{
ERR_PRINTF1(_L("Invalid local parent folder name specified"));
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF2(_L("The local parent folder Id is %d"),parentFolderId);
}
// Remote parent folder location...
else if(iLocation.Compare(_L("REMOTE"))==0)
{
TRAPD(err,parentFolderId = CT_MsgUtils::GetRemoteFolderIdByNameL(iSharedDataIMAP.iSession, iImapAccountName, iParentFolderName));
if(err == KErrNotFound)
{
ERR_PRINTF1(_L("Invalid remote parent folder name specified"));
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF2(_L(" The remote parent folder Id is %d"),parentFolderId);
}
// Location Local or Remote not specified...
else
{
ERR_PRINTF1(_L("Invalid parent folder location"));
SetTestStepResult(EFail);
return TestStepResult();
}
// Retrieves the message Id based on the message subject of the email under the given parent folder
TMsvId messageId;
TRAPD(err,messageId = CT_MsgUtils::SearchMessageBySubjectL(iSharedDataIMAP.iSession, parentFolderId, iEmailSubject));
if(err == KErrNotFound)
{
ERR_PRINTF1(_L("The given message is not found"));
SetTestStepResult(EFail);
}
// Message found
else
{
INFO_PRINTF2(_L("The Message Id is %d"),messageId);
// Retrieve the default Smtp service Id
TMsvId smtpServiceId(0);
TRAPD(err, smtpServiceId = CT_MsgUtilsCentralRepository::GetDefaultSmtpServiceIdL());
if(err != KErrNone)
{
ERR_PRINTF2(_L("Failure while getting the default SMTP Service Id. Error = %d"),err);
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(_L("The Default Smtp Service Id is %d"),smtpServiceId);
CT_MsgActive& active = Active();
delete iOperation;
iOperation=NULL;
// Setting the current context to the parent of the mesage
CMsvEntry* entry = CMsvEntry::NewL(*iSharedDataIMAP.iSession, messageId, TMsvSelectionOrdering());
CleanupStack::PushL(entry);
TMsvEmailEntry emailEntry(entry->Entry());
if(iEmailPriority==1)
{
emailEntry.SetFlaggedIMAP4Flag(ETrue);
iOperation = entry->ChangeL(emailEntry,active.iStatus);
active.Activate();
CActiveScheduler::Start();
User::LeaveIfError(active.Result());
INFO_PRINTF1(_L("The state of the Flagged IMAP4 flag of the email is set for urgent/special attention"));
}
else if (iEmailPriority==0)
{
emailEntry.SetFlaggedIMAP4Flag(EFalse);
iOperation = entry->ChangeL(emailEntry,active.iStatus);
active.Activate();
CActiveScheduler::Start();
User::LeaveIfError(active.Result());
INFO_PRINTF1(_L("The state of the Flagged IMAP4 flag of the email is NOT set for urgent/special attention"));
}
else
{
ERR_PRINTF1(_L("Error in setting the Flagged IMAP4 flag! Usage: 1=ETrue and 0=EFalse"));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(entry);
}
}
}
return TestStepResult();
}
//Returns TMsvEntry.iDate for aEntryId, and the time it is scheduled for on the task scheduler
EXPORT_C TInt CMsvTestUtils::ScheduleTime(TMsvId aEntryId, TTime& rEntryTime, TTime& rTaskSchedulerTime, TTaskInfo& rTaskInfo)
{
TRAPD(err, DoScheduleTimeL(aEntryId, rEntryTime, rTaskSchedulerTime, rTaskInfo));
return err;
}
enum TVerdict CTest07TrimStart::doTestStepL(void)
{
__UHEAP_MARK;
//-------------- substep 0 --------------------
Log(_L(" 00 Read parameters from the script:"));
TInt aOffset;// Will contain the position in chain where split action will be done
TInt aLength;// Will contain the length of desc & chains in the test
TInt bRet = GetIntFromConfig(_L("MBufMgrTest07"), _L("Length"), aLength);
if (!bRet)
{
return EFail;
}
bRet = GetIntFromConfig(_L("MBufMgrTest07"), _L("Offset"), aOffset);
if (!bRet)
{
return EFail;
}
Log(_L(" ------- Chain LENGTH = %d --"), aLength);
Log(_L(" ------- OFFSET where to TrimStart = %d --"), aOffset);
if ( (aLength > 1000) ||(aLength <0) ||
(aOffset > aLength) || (aOffset <0) )
{
Log(_L("ERROR: Wrong input parameter(s)"));
return EFail;
}
#ifdef __CFLOG_ACTIVE
__CFLOG_CREATEL;
__CFLOG_OPEN;
#endif
//-------------- substep 1 --------------------
Log(_L(" 01 Creating CMBufManager and installing active scheduler:"));
CleanupStack::PushL( iActSch = new(ELeave) CActiveScheduler );
CActiveScheduler::Install(iActSch);
CleanupStack::PushL(CreateInstanceMBufMgrL(KMBufDefaultHeapSize));
//-------------- substep 2 --------------------
Log(_L(" 02 Allocate two desc. of Length:LENGTH(Des1) & (LENGTH-OFFSET)(Des2):"));
TBuf8<1000> *aDes1, *aDes2;
CleanupStack::PushL( aDes1 = new(ELeave) TBuf8<1000> );
CleanupStack::PushL( aDes2 = new(ELeave) TBuf8<1000> );
aDes1->SetLength(aLength);
aDes2->SetLength(aLength-aOffset);
//-------------- substep 3 --------------------
Log(_L(" 03 Fill in Des1 with a pattern:"));
StripeDes(*aDes1, 0, aLength, '@', 'Z');
//-------------- substep 4 --------------------
Log(_L(" 04 Fill in Des2 with zeros:"));
StripeDes(*aDes2, 0, aLength-aOffset, 0, 0);
//-------------- substep 5 --------------------
Log(_L(" 05 Allocate Chain:"));
RMBufChain aChain;
TRAPD(ret,aChain.AllocL(aLength));
if (ret != KErrNone)
{
Log(_L("Error: Couldn't allocate RMBuf:"));
#ifdef __CFLOG_ACTIVE
__CFLOG_CLOSE;
__CFLOG_DELETE;
#endif
User::Leave(EFail);
}
//-------------- substep 6 --------------------
Log(_L(" 06 Copy in Des1 into Chain1:"));
aChain.CopyIn(*aDes1);
//-------------- substep 7 --------------------
Log(_L(" 07 TrimStart Chain1 at OFFSET position (actually, remove the 1st OFFSET bytes:"));
aChain.TrimStart(aOffset);
//-------------- substep 8 --------------------
Log(_L(" 08 Check the length of the chain. It should be (LENGTH - OFFSET):"));
TInt temp;
if ( (temp = aChain.Length()) != aLength-aOffset)
{
Log(_L("Error: Chain length is %d instead of %d"), temp, aLength-aOffset);
aChain.Free();
#ifdef __CFLOG_ACTIVE
__CFLOG_CLOSE;
__CFLOG_DELETE;
#endif
User::Leave(EFail);
}
//-------------- substep 09 --------------------
Log(_L(" 09 Copy the last (LENGTH-OFFSET) bytes of Des1 into the start of Des1:"));
(void)Mem::Copy((TUint8 *)aDes1->Ptr(), (TUint8 *)aDes1->Ptr()+aOffset, aLength-aOffset);
//-------------- substep 10 --------------------
Log(_L(" 10 Set the length of Des1 to value LENGTH-OFFSET"));
aDes1->SetLength(aLength-aOffset);
//-------------- substep 11 --------------------
Log(_L(" 11 Copy out Chain into Des2:"));
aChain.CopyOut(*aDes2);
//-------------- substep 12 --------------------
Log(_L(" 12 Compare the content of Des1 & Des2:"));
if(aDes1->Compare(*aDes2))
{
aChain.Free();
Log(_L("Error: The content is not the same"));
#ifdef __CFLOG_ACTIVE
__CFLOG_CLOSE;
__CFLOG_DELETE;
#endif
User::Leave(EFail);
}
//-------------- substep 13 --------------------
Log(_L(" 13 Free the chains. Clean up stack:"));
aChain.Free();
CleanupStack::PopAndDestroy(aDes2);
CleanupStack::PopAndDestroy(aDes1);
CleanupStack::PopAndDestroy(iMBMngr);
CActiveScheduler::Install(NULL);
CleanupStack::PopAndDestroy(iActSch);
#ifdef __CFLOG_ACTIVE
__CFLOG_CLOSE;
__CFLOG_DELETE;
#endif
__UHEAP_MARKEND;
return EPass;
}
/**
@SYMTestCaseID PDS-SQL-UT-4234
@SYMTestCaseDesc CSqlBurEventMonitor functional test
The test sets the backup & restore property status and then checks
how the backup & restore property monitor (CSqlBurEventMonitor) reacts to the event.
@SYMTestActions CSqlBurEventMonitor functional test
@SYMTestExpectedResults Test must not fail
@SYMTestPriority High
*/
void SqlBurEventMonitorFunctionalTest()
{
CSqlBurEventMonitor* monitor = NULL;
TRAPD(err, monitor = CSqlBurEventMonitor::NewL(*TheSqlSrvTestBurInterface));
TEST2(err, KErrNone);
TEST(!monitor->ActiveBackupClient());
TEST(!monitor->SqlBurCallback());
//Set the property to conn::EBURBackupFull, conn::EBURBackupPartial, conn::EBURRestoreFull, conn::EBURRestorePartial,
//then start the scheduler. CSqlBurEventMonitor::RunL() gets called and
//CSqlBurCallback and CActiveBackupClient interfaces get created (if the interfaces do exist, they are destroyed first).
TInt burPropertyStatus[] = {conn::EBURBackupFull, conn::EBURBackupPartial, conn::EBURRestoreFull, conn::EBURRestorePartial};
for(TInt i=0;i<(sizeof(burPropertyStatus)/sizeof(burPropertyStatus[0]));++i)
{
err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, burPropertyStatus[i]);
TEST2(err, KErrNone);
TestModeSqlBurError = KErrNone;
if(i > 0)
{
__UHEAP_MARK;
}
CActiveScheduler::Start();
if(i > 0)
{
__UHEAP_MARKEND;
}
TEST2(TestModeSqlBurError, KErrNone);
TEST(monitor->ActiveBackupClient() != NULL);
TEST(monitor->SqlBurCallback() != NULL);
}
//Set the property to conn::EBURUnset, start the scheduler. CSqlBurEventMonitor::RunL() gets called
//and CSqlBurCallback interface gets destroyed.
err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURUnset);
TEST2(err, KErrNone);
TestModeSqlBurError = KErrNone;
CActiveScheduler::Start();
TEST2(TestModeSqlBurError, KErrNone);
TEST(!monitor->ActiveBackupClient());
TEST(!monitor->SqlBurCallback());
//Set the property to conn::EBURNormal, start the scheduler. CSqlBurEventMonitor::RunL() gets called.
//CSqlBurCallback interface has been destroyed alread. No memory deallocations should be made during this call.
err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURNormal);
TEST2(err, KErrNone);
__UHEAP_MARK;
TestModeSqlBurError = KErrNone;
CActiveScheduler::Start();
TEST2(TestModeSqlBurError, KErrNone);
TEST(!monitor->ActiveBackupClient());
TEST(!monitor->SqlBurCallback());
__UHEAP_MARKEND;
//Set the property, then delete it. CSqlBurEventMonitor::RunL() should get called, but the call should
//fail because the property does not exist.
err = RProperty::Set(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, conn::EBURBackupFull);
TEST2(err, KErrNone);
err = RProperty::Delete(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey);
TEST2(err, KErrNone);
__UHEAP_MARK;
TestModeSqlBurError = KErrNone;
CActiveScheduler::Start();
TEST2(TestModeSqlBurError, KErrNotFound);
TEST(!monitor->ActiveBackupClient());
TEST(!monitor->SqlBurCallback());
__UHEAP_MARKEND;
//Restore the property
err = RProperty::Define(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey, 0);
TEST2(err, KErrNone);
//
delete monitor;
}
void CCamcTestClient_9::Start_Active_ObjectL ( TestClient9Actions aAction, TInt aCameraHandle )
{
TFileName file;
TInt camHandle = aCameraHandle;
TUid controllerUid = {0x101F8503}; //implementation uid
TUid formatUid = {0};
TUid formatUidG2 = {0x101F86D6};
TUid formatUidMP4 = {0x101F873D};
iAction = aAction; //iAction might be set to NULL after action has been executed
iSavedAction = aAction; //SavedAction will never be changed.
// iTimeout = aTimeout;
iTimeout = 1500000;
if ( iAction == K_TC9_NewFileNameWhenRecordSecondTimeDiffFileFormat )
{
AddDriveLetterToPath(_L("recordQCIF.3g2"), file);
TRAPD(err,
iCamc->OpenFileL( file, camHandle,
controllerUid,
formatUidG2,
_L8("video/H263-2000"),
TFourCC(' ', 'A', 'M', 'R') ));
if (err)
{
User::Leave(99);
}
}
else if ( iAction == K_TC9_NewFileNameWhenRecordSecondTimeMPEG4FileFormat )
{
AddDriveLetterToPath(_L("recordQCIF.mp4"), file);
TRAPD(err,
iCamc->OpenFileL( file, camHandle,
controllerUid,
formatUidMP4,
_L8("video/mp4v-es; profile-level-id=3"),
TFourCC(' ', 'A', 'A', 'C') ));
if (err)
{
User::Leave(99);
}
}
else
{
AddDriveLetterToPath(_L("recordQCIF.3gp"), file);
TRAPD(err,
iCamc->OpenFileL( file, camHandle,
controllerUid,
formatUid,
_L8("video/H263-2000"),
TFourCC(' ', 'A', 'M', 'R') ));
if (err)
{
User::Leave(99);
}
}
iOpenReady = EFalse;
// Main part of program is a wait loop
// This function completes when the scheduler stops
CActiveScheduler::Start();
if ( iError )
{
User::Leave( iError );
}
}
/** Deletes a setting.
@param aKey Key of setting to be deleted.
@return
KErrNone if successful,
KErrNotFound if the setting does not exist,
plus other system-wide error codes.
@post
Transactions fail on all error conditions except KErrNotFound.
Outside transactions: on success the deletion of the setting is persistent,
on failure the repository is unmodified.
@capability Dependent Caller must satisfy the write access policy for that key in the repository
*/
EXPORT_C TInt CRepository::Delete(TUint32 aKey)
{
TRAPD(err,iImpl->DeleteSettingL(aKey));
iImpl->RemoveAnyMarkDeleted();
return err;
}
void CSsTestStepProcStart::DoTestForMonitorAlreadyMonProcL()
{
INFO_PRINTF1( _L("\n\nPerforming Process-monitor test for already started and monitored process") );
RProcess process;
CleanupClosePushL(process);
CSsmStartupProperties* startupProperties = CSsmStartupProperties::NewL();
CleanupStack::PushL( startupProperties );
// Need to start testprocess as a server so that we can tell it to stop being monitored.
startupProperties->SetFileParamsL(KTestProcGood, KLaunchServerCommandLineOption);
startupProperties->SetCommandTypeL(ESsmCmdStartProcess);
startupProperties->SetExecutionBehaviour(ESsmWaitForSignal);
const TInt KMonitorTimeout = 3000; // milliseconds I presume
TSsmMonitorInfo monitorInfo;
monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
monitorInfo.iRestartMode = 0;
monitorInfo.iTimeout = KMonitorTimeout;
monitorInfo.iRetries = 1;
startupProperties->SetMonitorInfoL(monitorInfo);
CSsmStartSafe* ss = CSsmStartSafe::NewLC();
// Try to start and monitor the process
TRAPD(err, ss->StartAndMonitorL(*startupProperties, process));
TEST(err == KErrNone);
INFO_PRINTF3( _L("StartAndMonitorL() completed with %d. anticipated value %d"),err, KErrNone );
RTestProcGoodSession testProcServerSession;
err = testProcServerSession.Connect();
TEST(KErrNone == err);
INFO_PRINTF1( _L("Asserted that server is running"));
// Try to start and monitor an already started and monitored process
TRAP(err, ss->StartAndMonitorL(*startupProperties, process));
// sysmon returns KErrAlreadyExists, if we try to monitor an already monitored process
TEST(err == KErrAlreadyExists);
INFO_PRINTF3( _L("StartAndMonitorL() completed with %d. anticipated value %d"),err, KErrAlreadyExists);
process.Kill(KErrNone);
err = testProcServerSession.Connect();
//Connecting to the test proc server session should fail here with error value as either KErrNotFound(in case session object is cleaned up) or KErrServerTerminated(session object is there but session terminated)
TEST(KErrNotFound == err || KErrServerTerminated == err);
INFO_PRINTF3( _L("Connect to test proc server session failed with %d. anticipated value %d"),err, KErrNotFound);
RSemaphore sem;
err = sem.CreateGlobal(KStartProcSignalSemaphore, 0);
INFO_PRINTF2(_L("Created semaphore with err %d"),err);
TEST(err == KErrNone);
CleanupClosePushL(sem);
INFO_PRINTF1(_L("Waiting for Start of the test application"));
sem.Wait();
//Waiting for 5 seconds as in the ssmtestprocgood application the active scheduler
// will be started after signalling the semaphore. And we can connect to the
// application only after the active scheduler is started.
User::After(KWaitForActiveSchedStart);
// Check that the killed process is restarted by SysMon
err = testProcServerSession.Connect();
TEST(KErrNone == err);
INFO_PRINTF3( _L("process re-started by sysmon with %d, anticipate value %d"),err,KErrNone);
// Stop monitoring to stop restarts.
if(KErrNone == testProcServerSession.Connect())
{
testProcServerSession.CancelMonitor();
testProcServerSession.Close();
}
TEST(1 == FindAndKill(KTestProcGood));
CleanupStack::PopAndDestroy(4, &process);
}
/** Sets an existing integer setting to a new value or creates a new setting
with an integer value if the setting doesn't exist.
@param aKey Key of setting to be written to.
@param aValue Value to be written.
@return
KErrNone if successful,
KErrArgument if the setting exists but is not an integer
plus other system-wide error codes.
@post
Transactions fail on all error conditions.
Outside transactions: on success the new value is persistent,
on failure the repository is unmodified.
@capability Dependent Caller must satisfy the write access policy of that key in the repository.
*/
EXPORT_C TInt CRepository::Set(TUint32 aKey, TInt aValue)
{
TRAPD(err,iImpl->SetSettingL(aKey,aValue));
return err;
}
void CGroupViewTester::HandleContactViewEvent( const CContactViewBase& aView,
const TContactViewEvent& aEvent )
{
// Log events from both underlying view and group view.
LogEvent( const_cast<TContactViewEvent&>( aEvent ) );
switch (iCurrentTest)
{
case ECreateLocalView:
test(iLocalView==&aView);
test(aEvent.iEventType==TContactViewEvent::EReady);
break;
case ECreateGroupOneView:
{
test(iGroupViewOne == &aView);
test(aEvent.iEventType == TContactViewEvent::EReady);
//Reserve the IDs of last three contacts in the group
TInt index = KNumContactsInGroupOne-1;
TRAPD(err, iLastContactID = iGroupViewOne->ContactAtL(index).Id() );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning iLastContactID\n");
test.Printf(KErrMsg);
User::Invariant();
}
--index;
TRAP(err, iSecondLastContactID = iGroupViewOne->ContactAtL(index).Id() );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning iSecondLastContactID\n");
test.Printf(KErrMsg);
User::Invariant();
}
--index;
TRAP(err, iThirdLastContactID = iGroupViewOne->ContactAtL(index).Id() );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning iThirdLastContactID\n");
test.Printf(KErrMsg);
User::Invariant();
}
}
break;
case ECreateGroupTwoView:
test( iGroupViewTwo == &aView );
test( aEvent.iEventType == TContactViewEvent::EReady );
break;
case EDeleteItemsFromView:
{
// Bulk delete complete when the last Ready is received from the
// base view. This comes after the group view ready event. Break to
// run next test.
TBool lastEvent = (aEvent.iEventType == TContactViewEvent::EReady) &&
(&aView == iLocalView);
if (lastEvent)
{
break;
}
if (aEvent.iEventType == TContactViewEvent::EItemRemoved)
{
// Only proces events from group view.
if (&aView == iGroupViewOne)
{
// Ensure that only 1 contact is removed per notification.
iNumRemovedEvents++;
TInt numItemsExpected = KNumContactsInGroupOne - iNumRemovedEvents;
TInt numItems(0);
TRAPD(err, numItems = iGroupViewOne->CountL() );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning numItems\n");
test.Printf(KErrMsg);
User::Invariant();
}
test(numItems == numItemsExpected );
// Verify the contacts were deleted as expected.
TBool testVal(EFalse);
TInt index = numItemsExpected - 1;
TRAP(err, testVal = (iGroupViewOne->ContactAtL(index).Id() == iLastContactID) );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning testVal for iLastContactID\n");
test.Printf(KErrMsg);
User::Invariant();
}
test(testVal);
--index;
TRAP(err, testVal = (iGroupViewOne->ContactAtL(index).Id() == iSecondLastContactID) );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning testVal for iSecondLastContactID\n");
test.Printf(KErrMsg);
User::Invariant();
}
test(testVal);
--index;
TRAP(err, testVal = (iGroupViewOne->ContactAtL(index).Id() == iThirdLastContactID) );
if (err)
{
_LIT(KErrMsg, "Contact view error in CGroupViewTester::HandleContactViewEvent() assigning testVal for iThirdLastContactID\n");
test.Printf(KErrMsg);
User::Invariant();
}
test(testVal);
}
// More events expected, don't run next test.
return;
}
else
{
// Ignore all other events.
return;
}
}
case EAddItemToGroup:
{
// Break to run next test if this is the last expected event. The last
// event is the group being added from the base view. The local view
// removes and then adds the group id whenever the group changes. These
// events are meaningless.
TBool lastEvent = (&aView == iLocalView) &&
(aEvent.iEventType == TContactViewEvent::EItemAdded) &&
(aEvent.iContactId == iGroupOneId);
if (lastEvent)
{
break; // Run next test.
}
// Verify contact has been added.
if (aEvent.iEventType == TContactViewEvent::EItemAdded &&
&aView == iGroupViewOne)
{
// Check if contact was added.
test( aEvent.iContactId == iIdAdded );
TInt index = iGroupViewOne->FindL( iIdAdded );
test (index != KErrNotFound);
// More events expected, don't run next test.
return;
}
else
{
// Ignore all other events.
return;
}
}
default:
test( EFalse );
break;
}
// Run the next test.
if (--iNumNotificationExpected <= 0)
{
NextTest();
iNumNotificationExpected = 0;
}
}