自学教程：C++ ERR_PRINTF1函数代码示例

/** Verifies that GetAlarmSoundsSilentUntil API does not return KErrNone*/void CTestSystemChangeFor::VerifySilentUntil()	{	TTime getSilentUntil;	if(iAlarmServerSession.GetAlarmSoundsSilentUntil(getSilentUntil)!=KErrNone)		{		INFO_PRINTF1(_L("GetAlarmSoundsSilentUntil() != KErrNone"));		}	else		{		ERR_PRINTF1(_L("GetAlarmSoundsSilentUntil() == KErrNone"));		}	}

/**Test TRfcommRemotePortParams()*/void CT_RfcommRemotePortParamsData::DoCmdTRfcommRemotePortParams()	{	DestroyData();	INFO_PRINTF1(_L("TRfcommRemotePortParams Constructor Call"));	iData = new (ELeave) TRfcommRemotePortParams();		if ( iData == NULL ) 		{		ERR_PRINTF1(_L("TRfcommRemotePortParams is NULL"));		SetBlockResult(EFail);		}	}

/**  Virtual DoCancel - Request to cancel the asynchronous command  @publishedInternal  @see - MTPActiveCallback  @param aActive Active Object that DoCancel has been called on  @pre - N/A  @post - N/A  @leave system wide error code */ void CT_InquirySockAddrData::DoCancel(CActive* aActive, TInt /*aIndex*/) 	{ 	if ( aActive==iActive ) 		{ 		DoCancelGetDeviceAddress(); 		} 	else 		{ 		ERR_PRINTF1(_L("Stray signal")); 		SetBlockResult(EFail); 		} 	}

/** Virtual RunL - Called on completion of an a Synchronous command @publishedInternal @see MT_MMActiveCallback @param aActive Active Object that RunL has been called on @pre N/A @post N/A @leave system wide error code*/void CT_InquirySockAddrData::RunL(CActive* aActive, TInt aIndex) 	{ 	if ( aActive==iActive ) 		{ 		RunGetDeviceAddress(aIndex); 		} 	else 		{ 		ERR_PRINTF1(_L("Stray signal")); 		SetBlockResult(EFail); 		} 	}

void CTestCalInterimApiSuiteStepBase::Progress(TInt aPercentageCompleted)	{	if ( iNotifyProgress )		{		INFO_PRINTF2(KInfoPercentageCompleted, aPercentageCompleted);		}	else		{		ERR_PRINTF1(KErrPercentageCompleted);		SetTestStepResult(EFail);		}	}

TInt CTestFloat_blr::jn_test()	{ 	// Create temporary variables in stack  	char chParam[MAX_SIZE];  	FLOAT input1;  	FLOAT input2;  	FLOAT expected;  	FLOAT max_ulp;  	FLOAT gen_ulp;  	  	// Read parameters  	  	ReadStringParam ( chParam);    ReadFloatParam ( input1);    ReadFloatParam ( input2);    ReadFloatParam ( expected);    ReadFloatParam ( max_ulp);        //    TBuf<MAX_SIZE> buf;    TInt len = strlen(chParam);        for (TInt j =0; j<len;j++)    	{    	buf.Append(chParam[j]);		}        // Do some testing    FLOAT res = FUNC(jn) (input1, input2);            if(check_float(res, expected, max_ulp, gen_ulp))    	{    	INFO_PRINTF1(_L("Test passed."));    	}    else        	{    	ERR_PRINTF1(_L("Test Failed."));   		return KErrGeneral;    	}            INFO_PRINTF1(_L("_________________________________________/n"));    INFO_PRINTF2(_L("TestCase		  : %S/n"), &buf );    INFO_PRINTF2(_L("Input Value    : %f/n"), input1 );    INFO_PRINTF2(_L("Input Value    : %f/n"), input2 );    INFO_PRINTF2(_L("Expected Value : %f/n"), expected );	INFO_PRINTF2(_L("Max ULP value  : %f/n"), max_ulp );	INFO_PRINTF2(_L("Result  		  : %f/n"), res );	INFO_PRINTF2(_L("Generated Ulp  : %f/n"), gen_ulp );	INFO_PRINTF1(_L("_________________________________________/n"));     return KErrNone;	}

TInt CTestSendsignal::TestNegativeSigqueue1 (  )	{   	int ret1 = KErrGeneral, pid, pid1, ret, status;	union sigval sival;	char **argv=(char**)malloc(3*sizeof(char*));	argv[0]=(char*)malloc(34*sizeof(char));	argv[1]=(char*)malloc(3*sizeof(char));	argv[2]= 0;	strcpy(argv[0], "z://sys//bin//receivesignal.exe");	sprintf(argv[1], "%d", 0);		ret = posix_spawn(&pid, "z://sys//bin//receivesignal.exe", NULL, NULL, argv, (char**)NULL);	if(ret != 0)		{		ERR_PRINTF2(_L("Error in posix spawn and errno is set to %d"),errno);		goto close;		}	INFO_PRINTF2( _L("the value of pid returned by posix_spawn is %d"),  pid);	sival.sival_int = 0;	ret = sigqueue(pid,0,sival);	INFO_PRINTF1(_L("Negative test on sigqueue()"));	if(ret != 0)		{		ERR_PRINTF1(_L("Failed to set the return value"));			goto close;		}	pid1 = waitpid(pid, &status, WUNTRACED);	if (pid1 != pid)		{		ERR_PRINTF1(_L("waitpid failed..."));			goto close;		}		INFO_PRINTF1(_L("Kill() returned 0 as the process exists"));	ret1 = KErrNone;	close:	free((void*)argv[0]);	free((void*)argv[1]);	free((void*)argv);	return ret1;	}

/**@SYMTestCaseID			PIM-APP-ENGINES-CALINTERIMAPI-CIT-0006-HP@SYMTestType			CIT@SYMTestPriority		Medium@SYMPREQ				1098@SYMFssID				3.2.1 006@SYMTestCaseDesc		Lists all calendar  files@SYMTestActions			List all aganda files@SYMTestExpectedResults	Return all aganda files*/void CTestCalInterimApiFileAccess::ListsAllAgendaFilesL()	{	INFO_PRINTF1(KInfoListingAllAgendaFiles);	CDesCArray* 	agendaFiles(GetSession().ListCalFilesL());	CleanupStack::PushL(agendaFiles);	TInt			count;	for( count=0 ; count<agendaFiles->MdcaCount(); count++ )		{		INFO_PRINTF1(agendaFiles->MdcaPoint(count));		}	CleanupStack::PopAndDestroy(agendaFiles);	if ( count==0 )		{		ERR_PRINTF1(KErrListingAllAgendaFiles);		SetTestStepResult(EFail);		}	else		{		iSession->DeleteCalFileL(iCalenderFileName);		INFO_PRINTF1(_L("Listing out the files after the deletion of the file in the previous list"));		CDesCArray* 	agendaFileList(GetSession().ListCalFilesL());		CleanupStack::PushL(agendaFileList);		TInt 			fileCount;		for( fileCount=0; fileCount<agendaFileList->MdcaCount(); fileCount++)			{			INFO_PRINTF1(agendaFileList->MdcaPoint(fileCount));			}		if( fileCount == (count-1) )			{			INFO_PRINTF1(_L("ListCalFileL() has listed the files correctly"));			iSession->CreateCalFileL(iCalenderFileName);			}		else			{			ERR_PRINTF1(_L("Listing is not done properly"));			SetTestStepResult(EFail);			}		CleanupStack::PopAndDestroy(agendaFileList);		}		}

/**  Function : doTestStepL  Description : Checks the provisioned SNAP information for the POP account settings of a test case.  @return : TVerdict - Test step result*/		TVerdict CT_MsgCheckPopSNAPSetting::doTestStepL()	{	INFO_PRINTF1(_L("Test Step : CheckPopSNAPSetting"));	if(ReadIni())		{		CEmailAccounts* accounts = CEmailAccounts::NewL();		CleanupStack::PushL(accounts);				CImIAPPreferences* popIapPrefs = CImIAPPreferences::NewLC();							TPopAccount popAccountId;		CT_MsgUtilsCentralRepository::GetPopAccountL((TDes&)iPopAccountName,popAccountId);						accounts->LoadPopIapSettingsL(popAccountId, *popIapPrefs);					TBool actualSNAPDefintion = popIapPrefs->SNAPDefined();				if (actualSNAPDefintion == iExpectedSNAPDefinition)			{			if (actualSNAPDefintion)				{				TInt expectedSNAPPreference = 0;				if(!GetIntFromConfig(ConfigSection(), KSNAPPreference, expectedSNAPPreference))					{					ERR_PRINTF1(_L("An expected SNAP ID value is not specified"));					SetTestStepResult(EFail);					CleanupStack::PopAndDestroy(2,accounts); // popIapPrefs, accounts					return TestStepResult();					}				TInt actualSNAPPreference = popIapPrefs->SNAPPreference();								if (actualSNAPPreference != expectedSNAPPreference)					{					ERR_PRINTF3(_L("Actual SNAP ID [%d] does not equal Expected SNAP ID [%d]"),actualSNAPPreference,expectedSNAPPreference);					SetTestStepResult(EFail);					}				else					{					INFO_PRINTF3(_L("Actual SNAP ID [%d] equals Expected SNAP ID [%d]"),actualSNAPPreference,expectedSNAPPreference);					}				}			}		else			{			ERR_PRINTF3(_L("Actual SNAP Defintion [%d] does not equal Expected SNAP Defintion [%d]"),actualSNAPDefintion,iExpectedSNAPDefinition);			SetTestStepResult(EFail);			}			CleanupStack::PopAndDestroy(2,accounts); // popIapPrefs, accounts		}	return TestStepResult();	}

TVerdict CSysUtilsGetSWVersionNoNewLinesStep::doTestStepL()	{	TInt err = SetTestPath(ETrue);	if( err != KErrNone )		{		ERR_PRINTF2(_L("Could not turn test path on. Error = %d"), err);		SetTestStepResult(EAbort);		return TestStepResult();		}	INFO_PRINTF1(_L("Test path turned on."));		err = DeletePSProperties();	if( err != KErrNone )		{		ERR_PRINTF2(_L("Could not delete P&S properties. Error = %d"), err);		SetTestStepResult(EAbort);		}	INFO_PRINTF1(_L("Deleted P&S properties successfully."));		_LIT16(KDummy,"xxxxx");	TBuf16<KSysUtilVersionTextLength> version;	version.Insert(0,KDummy);	err = SysUtil::GetSWVersion( version );		if ( err == KErrNone)		{		_LIT(KSw, "SW");		TPtrC16 line;		TESTL( GetStringFromConfig(ConfigSection(), KSw, line) );		TBuf16<KSysUtilVersionTextLength> testBuf(line);		if (version.Compare(testBuf)==0)			{			INFO_PRINTF1(_L("Got version "));			INFO_PRINTF1(version);			}		else			{			ERR_PRINTF1(_L("Version not correct"));			SetTestStepResult(EFail);			}		}	else 		{		ERR_PRINTF2(_L("Error code = %d"), err);		SetTestStepResult(EFail);		}				return TestStepResult();	}

TInt CTestSendsignal::TestNegativeSigqueue3 (  )	{  	int Maxsig, Pid, Signum, ret, ret1 = KErrGeneral, Sigval;	union sigval sival;	ret = GetIntFromConfig(ConfigSection(), _L("Pid"), Pid);	if(ret == 0)		{		ERR_PRINTF1(_L("Failed to read the Process id number")) ;		goto close;		}		ret = GetIntFromConfig(ConfigSection(),_L("Sigval"), Sigval);	if(ret == 0)		{		ERR_PRINTF1(_L("Failed to read the signal number")) ;		goto close;		}	ret = GetIntFromConfig(ConfigSection(),_L("Maxsig"), Maxsig);	if(ret == 0)		{		ERR_PRINTF1(_L("Failed to read the Maximum sig value")) ;		goto close;		}	INFO_PRINTF1(_L("Negative test on sigqueue()"));	for(Signum=Sigval; Signum <= Maxsig; Signum++)		{		sival.sival_int = 0;		ret = sigqueue(Pid,Signum,sival);		if((ret != -1) || (errno != ESRCH))			{			ERR_PRINTF2(_L("Failed to set the return value for signal %d"), Signum);				goto close;			}		}	INFO_PRINTF1(_L("Negative test: Both the errno and expected value of kill() are same validated for all signals"));	ret1 = KErrNone;	close:	return ret1;	}

/** Converts the text encoded in a non-Unicode character set into the Unicode character set @param	aSource The non-Unicode source text to be converted@param	aUnicode Contains the converted text in the Unicode character @test*/void CTestHtmlToCrtConverterBufferStep::ConvertBufferDirectly(const TDesC8& aSource, TDes& aUnicode)	{	TInt	state = CCnvCharacterSetConverter::KStateDefault;	// Converts text encoded in a non-Unicode character set into the Unicode character set 	TInt	returnValue = iCnvCharacterSetConverter->ConvertToUnicode(aUnicode, aSource, state);	// return value is 0 if entire buffer converted	if( returnValue != KErrNone )		{		ERR_PRINTF1(KErrInConversion);		SetTestStepResult(EFail);		}	}

void CTestBlockController::StoreActiveScheduler(TTEFBlockItem& aCommand)	{	if( IsSharedDataMode() )		{		// Don't delete the persistent active scheduler		iDeleteSharedScheduler = EFalse;		}	else		{		aCommand.iError = KErrNotSupported;		ERR_PRINTF1(KErrSharedMode);		}	}

/**  Function : ReadIni  Description :Reads the corresponding .ini file and returns EPass or EFail if any of the inputs are missing  @return : TBool*/TBool CT_MsgRemoveSmtpSNAPSetting::ReadIni()	{	TBool result = ETrue;		if(!GetStringFromConfig(ConfigSection(), KSmtpAccountName, iSmtpAccountName))		{		ERR_PRINTF1(_L("Smtp account name is not specified"));		SetTestStepResult(EFail);		result = EFalse;		}			return result;	}

/** Calls CFbsFont::Handle() */void CT_DataFbsFont::DoCmdHandle()	{	// call Handle()	TInt	handle = iFbsFont->Handle();	INFO_PRINTF2(_L("Calls CFbsFont::Handle() %d"), handle);	// validate hanle	if (handle == 0)		{		ERR_PRINTF1(_L("Handle is zero!"));		SetBlockResult(EFail);		}	}

TTimeIntervalSeconds CSchSendStepBase::ReadUTCOffsetL()	{	TInt offset;	//read the utc offset	if(!GetIntFromConfig(ConfigSection(),_L("UTCOffset"),offset))		{		ERR_PRINTF1(_L("Error reading UTC offset from ini file"));		User::Leave(KErrArgument);			}	TTimeIntervalSeconds interval(offset);			return interval;		}

void CT_DataRSocketServ::DoCmdDestructor()	{	if( iSocketServ )		{		INFO_PRINTF1(_L("Calling RSocketServ Destructor"));		delete iSocketServ;		iSocketServ = NULL;		}	else		{		ERR_PRINTF1(_L("RSocketServ object invalid, can't call destructor"));		SetBlockResult(EFail);		}	}

TVerdict CEglTest_LocalTestStep_EndpointApiExposure::doTestStepL()    {    //First, test the local side.    //temp solution. We probably want an Egl helper class for the local side too.    eglInitialize(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL);    //Check that the extension does not exist in the egl implementation.    TPtrC8 extensionString((TUint8*)eglQueryString(eglGetDisplay(EGL_DEFAULT_DISPLAY), EGL_EXTENSIONS));    _LIT8(KExtensionName, "EGL_NOK_image_endpoint");    if(extensionString.Find(KExtensionName) != KErrNotFound)        {        ERR_PRINTF1(_L("Incorrect result for extensionString"));        INFO_PRINTF1(_L("Rest of test is being skipped due to failure."));        eglTerminate(eglGetDisplay(EGL_DEFAULT_DISPLAY));        SetTestStepResult(EFail);        return TestStepResult();        }    else        {        INFO_PRINTF1(_L("Correct result for extensionString"));        }    //If this function leaves, a function pointer was returned from EGL.    //Since we are outside wserv, we expect EGL never to advertise the existance    //of the Endpoint API.    TRAPD(err, AttemptToGetProcAddressForAllEndpointFunctionsL());    if(err != KErrNone)        {        INFO_PRINTF1(_L("Rest of test is being skipped due to failure."));        eglTerminate(eglGetDisplay(EGL_DEFAULT_DISPLAY));        SetTestStepResult(EFail);        return TestStepResult();        }    eglTerminate(eglGetDisplay(EGL_DEFAULT_DISPLAY));    //Now test remote side.    //Params for the remote test step.    TRemoteTestParams params;    //Run the test step and return the result.    StartRemoteTestStep(TRemoteTestParams());    RunRemoteTestCase(0, params);    EndRemoteTestStep(TRemoteTestParams());    return TestStepResult();    }

TVerdict CAppFwkStartSafeTestStepAppTimeout::doTestStepL( void )	{		CStartSafe *startSafe = CStartSafe::NewL();		CleanupStack::PushL( startSafe );		CStartupProperties *prop = CStartupProperties::NewL();	CleanupStack::PushL( prop );		RProcess proc;	CleanupClosePushL( proc );		prop->SetFileParamsL( KTestAppSlow, KNullDesC );	prop->SetStartupType( EStartApp );	prop->SetStartMethod( EWaitForStart );	prop->SetNoOfRetries( 0 );	prop->SetTimeout( KWaitTime );		TInt tried = 0;					INFO_PRINTF2( _L("Start the app and wait for %d milliseconds"), KWaitTime );		TRAPD( err, startSafe->StartL(*prop, proc, tried) );		if ( KErrTimedOut == err )		{		SetTestStepResult( EPass );		INFO_PRINTF1( _L("Timed out - Test passed") );		}	else		{		SetTestStepResult( EFail );		ERR_PRINTF1( _L("No time-out - Test failed") );				TPtrC procNamePtr = proc.FileName().Right( KTestAppSlow().Length() );		// Check that the process is the app we think it is.		if( 0 == procNamePtr.Compare( KTestAppSlow()) )			{			proc.Kill( KErrNone );				}					}					CleanupStack::PopAndDestroy( 3, startSafe );	return TestStepResult();		}

TVerdict CTestUnpadCorruptPKCS7::doTestStepL() 	{ 	SetTestStepResult(EPass); 	__UHEAP_MARK;  	TInt blockSize; 	TInt textSize; 	TInt paddingNum = 0; 	 	if (GetIntFromConfig(ConfigSection(), _L("blocksize"), blockSize)) 		{ 		if (GetIntFromConfig(ConfigSection(), _L("textsize"), textSize)) 			{ 			if (GetIntFromConfig(ConfigSection(), _L("paddingbyte"), paddingNum)) 				{ 				INFO_PRINTF1(_L("Test of PKCS7 unpadding with corrupt data")); 				TUint8 paddingByte = Min(paddingNum, 255);   				TestCorruptPKCS7Unpadding(blockSize, textSize, paddingByte);	  					 				}				 			else 				{ 				ERR_PRINTF1(_L("Missing parameter - paddingbyte")); 				} 			} 		else 			{ 			ERR_PRINTF1(_L("Missing parameter - textsize")); 			} 		} 	else		{ 		ERR_PRINTF1(_L("Missing parameter - blocksize")); 		}  	__UHEAP_MARKEND; 	return TestStepResult(); 	}

/**doTestStepL()It establishes connection with the Pop server using a POP account.The account is identified by the account name that is read from the INI file.@returnReturns the test step result*/TVerdict CT_MsgConnectPop3Server::doTestStepL()	{		INFO_PRINTF1(_L(" Test Step : ConnectPop3Server"));	TPtrC popAccountName;	if(!GetStringFromConfig(ConfigSection(), KPopAccountName, popAccountName))		{		ERR_PRINTF1(_L("Pop Account Name is not specified"));		SetTestStepResult(EFail);		}	else		{		// Retrieving the Pop service Id for the given Pop account		TMsvId popServiceId = CT_MsgUtilsCentralRepository::GetPopServiceIdL((TDes&)popAccountName);		INFO_PRINTF2(_L("Pop service id is %d"),popServiceId);		// Change the current context		iSharedDataPOP.iMtm->SwitchCurrentEntryL(popServiceId);		CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;		CleanupStack::PushL(selection);		// Appends the popServiceId onto the end of the array		selection->AppendL(popServiceId);				TBuf8<KMaxLenghtOfChar> param;		CT_MsgActive&	active=Active();		// Attempts to connect to the Pop3 Service		iOperation = iSharedDataPOP.iMtm->InvokeAsyncFunctionL(KPOP3MTMConnect,*selection,param, active.iStatus);		active.Activate();		CActiveScheduler::Start();			// Get the error code from TPop3Progress		TPop3Progress temp;		TPckgC<TPop3Progress> paramPack(temp);		paramPack.Set(iOperation->ProgressL());		TPop3Progress progress=paramPack();		SetTestStepError(progress.iErrorCode);		delete iOperation;		iOperation=NULL;				CleanupStack::PopAndDestroy(selection); //operation,selection	//	User::LeaveIfError(active.Result());		}	return TestStepResult();	}

void CT_TCommCapsV02Data::DoCmdiRoleCaps(const TDesC& aSection)	{	TUint	actual=GetCommCapsV02().iRoleCaps;	INFO_PRINTF2(_L("iRoleCaps : 0x%x"), actual);	TUint	expected;	if ( ReadRoleCaps(aSection, KFldExpected(), expected) )		{		if ( expected!=actual )			{			ERR_PRINTF1(_L("Expected Value does not match actual"));			SetBlockResult(EFail);			}		}	}

void RTestStepMmfCtlfrmDualAudio::CancelReceivedEvents(TInt aWhichController){    RMMFController* theController;    // which controller are we searching on?    if(aWhichController == 1)        theController = &iController1;    else if(aWhichController == 2)        theController = &iController2;    else    {        ERR_PRINTF1(_L("CancelReceivedEvents error : controller must be 1 or 2"));        return;    }    (*theController).CancelReceiveEvents();}

void CTestBlockController::CommandL(TTEFBlockItem& aCommand, const TInt aAsyncErrorIndex)	{	// Retrieve the object name from the ini file	TPtrC	name;	if( 0 != aCommand.iCommand.iObject.Compare(KTEFNull) &&		GetStringFromConfig(aCommand.iCommand.iObject, KName, name) )		{		CDataWrapper*	data = iDataDictionary.GetDataL(name);		if( data!=NULL )			{			TBool cmdExists = EFalse;			TRAPD(err, cmdExists = data->DoCommandL(aCommand.iCommand.iFunction, aCommand.iSection, aAsyncErrorIndex));			if (KErrNone != err)				{				ERR_PRINTF4(_L("Command /"%S/" of the object /"%S/" leaves with error code %d"), &aCommand.iCommand.iFunction, &aCommand.iCommand.iObject, err);				aCommand.iError = err;				SetBlockResult(EFail);				}			else if( !cmdExists )				{				ERR_PRINTF1(KErrNoFunction);				aCommand.iError = KErrNotFound;				}			}		else			{			ERR_PRINTF1(KErrNotExist);			aCommand.iError = KErrNotFound;			}		}	else		{		ERR_PRINTF1(KErrNoName);		aCommand.iError = KErrNotFound;		}	}

void RA3FDevSoundTestBase::BufferToBeFilled(CMMFBuffer* aBuffer)	{	INFO_PRINTF1(_L("========== DevSound BufferToBeFilled() callback =========="));	if (!aBuffer)		{		ERR_PRINTF1(_L("BufferToBeFilled callback received a NULL CMMFBuffer!"));		StopTest(KErrGeneral);		}	else		{		iBuffer = aBuffer;			INFO_PRINTF1(_L("DevSound Event: EEventBTBF"));		Fsm(EEventBTBF, KErrNone);		}		}

// Do the test step.TVerdict RTestMmTsthU2002::DoTestStepL()	{	INFO_PRINTF1(_L("Unit test for TestFrameworkServer - Server Session"));	TVerdict currentVerdict = EPass;	// create and install the active scheduler we need	CActiveScheduler* theScheduler = new(ELeave) CActiveScheduler;	CleanupStack::PushL(theScheduler);	CActiveScheduler::Install(theScheduler);	//	CMmfIpcServer* theServer = NULL;	TRAPD(err, theServer = CTestFrameworkServer::NewL());	if(err != KErrAlreadyExists)		{		TPtrC errortxt = CLog::EpocErrorToText(err);		ERR_PRINTF2(_L("Server not already running, create returned %S"), &errortxt);		delete theServer;		CleanupStack::PopAndDestroy(theScheduler);		return iTestStepResult = EInconclusive;		}	// setup local logger - this will cause a server session to be created	// (we can't get a handle to it!)	CLog* logClient	= CLog::NewLC();	logClient->OpenLogFileL();	TInt status = logClient->LogStatus();	// this will have retrieved log status from the server - the value is dependent on	// params passed into TestFramework, but in all cases will be nonzero. this demonstrates	// that a server session is running	if(status == 0)		{		ERR_PRINTF1(_L("Log status is zero - server session may not be running"));		currentVerdict = EFail;		}	else		{		INFO_PRINTF2(_L("Log status %d retrieved from server session"), status);		currentVerdict = EPass;		}	// cleanup the logger and the scheduler	CleanupStack::PopAndDestroy(2); // logClient, theScheduler	return iTestStepResult = currentVerdict;	}

TVerdict CTestUTCSort::TestSortingL()	{		TVerdict result=EPass;	//create ordering objects	TMsvSelectionOrdering ordering;		ordering.SetSorting(EMsvSortByDate);		//sort the gloabl inbox by date	CMsvEntry* inboxEntry = CMsvEntry::NewL(*iSession, KMsvDraftEntryIdValue,ordering);	CleanupStack::PushL(inboxEntry);		//retrieve the children of the inbox	CMsvEntrySelection* msvEntrySelection;	msvEntrySelection=inboxEntry->ChildrenL();	CleanupStack::PushL(msvEntrySelection);		CMsvEntry* child;	TMsvEntry childDetails;	TBuf<45> dateTimeString;		//look at the id of each child and test its id, these should	//be in the order the entries were created.	for(TInt i=0;i<KNumEmailMessages;++i)		{		child=iSession->GetEntryL((*msvEntrySelection)[i]);		childDetails=child->Entry();		delete child;		//print the time of the entry to the log file				dateTimeString.Zero();		FormatDateTime(dateTimeString,childDetails.iDate); 		INFO_PRINTF2(_L("%S"),&dateTimeString);						if(childDetails.Id()!=iTMsvIdList->At(i))			{			ERR_PRINTF1(_L("Entries in wrong order"));				result=EFail;			break;			}		}	CleanupStack::PopAndDestroy(msvEntrySelection);	CleanupStack::PopAndDestroy(inboxEntry);	return result;		}

void CApStartTestStep::TestStartAndForgetL(RWsSession& aWsSession)	{	INFO_PRINTF1(_L("Entering test case: APPFWK-APSTART-0001"));		TApaTask task = TestStartL(NULL, aWsSession);		if(task.Exists())		{		task.KillTask();		INFO_PRINTF1(_L("Leaving test case: APPFWK-APSTART-0001/n"));		}	else		{		ERR_PRINTF1(_L("APPFWK-APSTART-0001 failed/n"));  		}	}