Пример #1
0
GLDEF_C void CallTestsL(/*TChar aDriveLetter*/)
//
// Do all tests
//
	{
	if( !PlatSec::IsCapabilityEnforced(ECapabilityDiskAdmin))
		{
		test.Printf(_L("Capability ECapabilityDiskAdmin not enabled - leaving t_dcdiskadmin"));
		test.Printf(_L("\n")); // Prevent overwrite by next print
		return;
		}

	TurnAllocFailureOff();
	TheFs.CharToDrive(gDriveToTest,gTheDriveNum);
	
	TBuf<30> sesspath;
	sesspath=_L("?:\\");
	sesspath[0] = (TText)gDriveToTest;

	TInt r= TheFs.SetSessionPath(sesspath);
	test_KErrNone(r);

	//cleanup from previous run of this test
	TBuf<2> cmd;
	cmd.SetLength(1);
	cmd[0] = (TText)gDriveToTest;
	RProcess tp;
	r=tp.Create(_L("clean_prepdc.exe"),sesspath);
	test_KErrNone(r);
	{
	TRequestStatus ps;
	tp.Logon(ps);
	tp.Resume();
	tp.Close();
	User::WaitForRequest(ps);
	}

	//check double mode ie that Defpath still works	
	RFs fs1;
	RFs fs2;
	
	r=fs1.Connect();
	test_KErrNone(r);
	r=fs1.SessionPath(sesspath);
	test_KErrNone(r);
	test.Printf(_L("session1 Path=%S"),&sesspath);

	TBuf<30> privatepath;
	r=fs1.SetSessionToPrivate(gTheDriveNum);
	test_KErrNone(r);
	r=fs1.PrivatePath(privatepath);
	test_KErrNone(r);
	r=privatepath.Compare(KExpectedPrivatePath());
	test_Value(r, r == 0);
	r=fs1.SessionPath(sesspath);
	test_KErrNone(r);
	r=privatepath.Compare(sesspath.Mid(KPathPosition));
	test_Value(r, r == 0);
	r=fs1.CreatePrivatePath(gTheDriveNum);
	test_KErrNone(r);
	fs1.Close();

	r=fs2.Connect();
	test_KErrNone(r);
	r=fs2.SessionPath(sesspath);
	test_KErrNone(r);
	test.Printf(_L("session2 Path=%S"),&sesspath);
	fs2.Close();

	TestCaps();

	test.Printf(_L("No of files open=%d"), TheFs.ResourceCount());

	CleanupL();
	}
/**
 * Load and initialise an audio file.
 */
TVerdict CTestMmfAclntFileHandleSource::DoTestStepL( void )
	{
	INFO_PRINTF1( _L("TestPlayerUtils : File"));
	TVerdict ret = EFail;

	iError = KErrTimedOut;
	
	// Get the file name.
	TBuf<KSizeBuf> filename;
	TPtrC filename1;
	if(!GetStringFromConfig(iSectName,iKeyName,filename1))
		{
		return EInconclusive;
		}
	GetDriveName(filename);
	filename.Append(filename1);
	
	// Create CMdaAudioPlayerUtility Object
	CMdaAudioPlayerUtility* player = NULL;
	player = CMdaAudioPlayerUtility::NewL(*this);
	
	// Create RFs and RFile Objects
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	User::LeaveIfError(fs.ShareProtected());
	
	RFile file;
	User::LeaveIfError( file.Open( fs, filename, EFileRead ) );
	CleanupClosePushL(file);
	
	// Create TMMFileSource Object
	TMMFileHandleSource filehandlesource(file);
	player->OpenFileL(filehandlesource);
	
	// Wait for initialisation callback
	INFO_PRINTF1(_L("CMdaAudioPlayerUtility->OpenFileL(TMMFileHandleSource)"));
	CActiveScheduler::Start();
	
	// Check for expected errors.
	if((iError != KErrNone) && (iExpectedError == iError))
		{
		ERR_PRINTF2(_L("CMdaAudioPlayerUtility->OpenFileL() Returned the Expected Error : %d"),iError);
		ret=EPass;
		}
	
	// Check for errors.
	if(iError != KErrNone)
		{
		ERR_PRINTF2(_L("CMdaAudioPlayerUtility->OpenFileL() Failed with Error : %d"),iError);
		ret=EFail;
		}
	
	// Check for No errors, so as to start Playback
	if (iError == KErrNone && player != NULL)
		{
		if(iPlay)
			{
			iError = KErrTimedOut;
			player->Play();
			
			// Wait for play complete callback
			INFO_PRINTF1(_L("CMdaAudioPlayerUtility->Play()"));
			CActiveScheduler::Start();
			
			// Check for Callback errors
			if(iError == KErrNone)
				{
				ERR_PRINTF2(_L("CMdaAudioPlayerUtility->Play() completed successfully with return code : %d"),iError);
				ret = EPass;
				}
			else
				{
				ERR_PRINTF2(_L("CMdaAudioPlayerUtility->Play() Failed with Error : %d"),iError );
				ret = EFail;
				}
			}
		else
			{
			ret = EPass;
			}
		}
	
	// Clean up activities.
	delete player;
	User::After(KOneSecond); // wait for deletion to shut down devsound
	CleanupStack::PopAndDestroy(2);

	return	ret;
	}
Пример #3
0
/**
* Performes the test by connecting to MLFW and makes 50 Location request
*/
TInt DoTestL()
{
    TBuf<40> traceFile = GenerateFileNameForTraceL();

    RFs fileserver;
    RFile file;
    User::LeaveIfError(fileserver.Connect());
    CleanupClosePushL(fileserver);
    User::LeaveIfError(file.Open(fileserver, traceFile, EFileWrite));
    CleanupClosePushL(file);
    _LIT(KClientStarted, "Client Started");
    TraceL(KClientStarted, file);

    const TInt32 KUidMultiPsy = 0x01010176;
    TUid uidMultiPsy;
    uidMultiPsy.iUid = KUidMultiPsy;
    SetupPsyL(uidMultiPsy);

    _LIT(KMultiPsySetup, "MultiPsy set up");
    TraceL(KMultiPsySetup, file);

    TInt numberOfRuns = 50;

    RPositionServer	posServer;
    CleanupClosePushL(posServer);
    RPositioner positioner;
    CleanupClosePushL(positioner);
    TPositionInfo positionInfo = TPositionInfo();

    _LIT(KConnectErr, "ERROR: Error when connecing to EPos server,  %d");
    TInt err = posServer.Connect();
    AssertTrueL(err == KErrNone, KConnectErr, err, file);

    _LIT(KOpenErr, "ERROR: Error when opening positioner,  %d");
    err = positioner.Open(posServer, uidMultiPsy);
    AssertTrueL(err == KErrNone, KOpenErr, err, file);

    _LIT(KService ,"Service");
    err = positioner.SetRequestor(CRequestor::ERequestorService,
                                  CRequestor::EFormatApplication, KService);
    _LIT(KRequestor, "ERROR: Not possible to set requestor");
    AssertTrueL(err == KErrNone, KRequestor, err, file);

    TTime now, startTime;
    TTimeIntervalMicroSeconds requestTime;
    TRequestStatus status;
    TInt64 reqTime;
    TCoordinate corr(0,0,0);
    TLocality loca(corr,0);
    TPosition pos(loca, TTime(0));
    TBool success = ETrue;
    _LIT(KStartingRequests, "Starting requests");
    TraceL(KStartingRequests, file);

    for (TInt i = 0; i < numberOfRuns; i++)
    {
        startTime.UniversalTime();
        positionInfo.SetPosition(pos);
        positioner.NotifyPositionUpdate(positionInfo, status);
        User::WaitForRequest(status);
        err = status.Int();
        if (err != KErrNone)
        {
            success=EFalse;
        }
        now.UniversalTime();
        requestTime = now.MicroSecondsFrom(startTime);
        _LIT(KError, "Request time, %d µs. Error code from Notify = %d");
        TBuf<100> buf;
        reqTime = requestTime.Int64();
        buf.Format(KError, reqTime, err);
        TraceL(buf, file);
        TPosition result;
        positionInfo.GetPosition(result);
        // Sanity check
        if (result.Latitude() == pos.Latitude() ||
                result.Longitude() == pos.Longitude() ||
                result.Altitude() == pos.Altitude())
        {
            success = EFalse;
            _LIT(KErrorPositon, "ERROR:: The postion was not updated");
            TraceL(KErrorPositon, file);
        }
    }

    CleanupStack::PopAndDestroy(&positioner);
    CleanupStack::PopAndDestroy(&posServer);

    if (success)
    {
        _LIT(KOk, "SUCCESS");
        TraceL(KOk, file);
    }
    else
    {
        _LIT(KErr, "FAILED");
        TraceL(KErr, file);
    }

    CleanupStack::PopAndDestroy(&file);
    CleanupStack::PopAndDestroy(&fileserver);

    return (success) ? 0 : 1;
}
Пример #4
0
TInt TRPSOwnNumbers::ExtractANumber(const RMobileONStore::TMobileONEntryV1& aEntry)
	{
	TInt ret(KErrNotFound);
	
	TBuf<1> prependstr;
	prependstr.Zero();
	if(aEntry.iNumber.iTypeOfNumber == RMobilePhone::EInternationalNumber || 
	   aEntry.iNumber.iTelNumber.Left(2) == KUKCountryCode)
		{
		prependstr = KPlus;
		}
		
	// Check if entry's Service tag is set and extract number
	switch(aEntry.iService)
		{
		case RMobilePhone::EVoiceService:
			if(iOwnVoiceNumber.Length()==0)
				{					
				 iOwnVoiceNumber = prependstr;
				 iOwnVoiceNumber += aEntry.iNumber.iTelNumber;
			 	}
			ret = KErrNone;
			break;
		case RMobilePhone::ECircuitDataService:
			if(iOwnDataNumber.Length()==0)
				{
				iOwnDataNumber = prependstr;
				iOwnDataNumber += aEntry.iNumber.iTelNumber;
				}
			ret = KErrNone;
			break;
		case RMobilePhone::EFaxService:
			if(iOwnFaxNumber.Length()==0)
				{
				iOwnFaxNumber = prependstr;
				iOwnFaxNumber += aEntry.iNumber.iTelNumber;
				}
			ret = KErrNone;
			break;
			
		default:
			{
			// Else check the text tag, assuming the user has set the text tag according to the RPS
			// user guide
			if(iOwnVoiceNumber.Length()==0)
				{
				if(aEntry.iText.Match(KVoiceTagU)!= KErrNotFound || aEntry.iText.Match(KVoiceTagL)!= KErrNotFound)
					{
					// Assume this is the voice line
					iOwnVoiceNumber = prependstr;
				 	iOwnVoiceNumber += aEntry.iNumber.iTelNumber;
					ret = KErrNone;
					}
				}
				
			if(iOwnFaxNumber.Length()==0)
				{
				if(aEntry.iText.Match(KFaxTagU)!= KErrNotFound || aEntry.iText.Match(KFaxTagL)!= KErrNotFound)
					{
					// Assume this is the fax line
					iOwnFaxNumber = prependstr;
					iOwnFaxNumber += aEntry.iNumber.iTelNumber;		
					ret = KErrNone;
					}
				}
					
			if(iOwnDataNumber.Length()==0)
				{
				if(aEntry.iText.Match(KDataTagU)!= KErrNotFound || aEntry.iText.Match(KDataTagL)!= KErrNotFound)
					{
					// Assume this is the data line
					iOwnDataNumber = prependstr;
					iOwnDataNumber += aEntry.iNumber.iTelNumber;
					ret = KErrNone;
					}
				}					
			}
			break;
		}
	return ret;
	}
// ----------------------------------------------------
// CDbtestAppUi::HandleCommandL(TInt aCommand)
// ?implementation_description
// ----------------------------------------------------
//
void CDbtestAppUi::HandleCommandL(TInt aCommand)
{
	switch ( aCommand )
        {
        case EAknSoftkeyBack:
        case EEikCmdExit:
		{
			Exit();
			break;
		}
	case EdbtestCmdAppOBEX:
		//bt->transfer_logs();
		break;
        case EdbtestCmdAppTest:
		{
#if 0
			if (!is_open) {
				User::LeaveIfError(sockserv.Connect());
				User::LeaveIfError(sock.Open(sockserv, KAfInet, KSockStream, KUndefinedProtocol));
				TInetAddr a(INET_ADDR(128, 214, 48, 81) , 80);

				TRequestStatus s;
				sock.Connect(a, s);
				User::WaitForRequest(s);
				status_change(_L("opened"));
				is_open=true;
			} else {
				sock.CancelAll();
				sock.Close();
				sockserv.Close();
				status_change(_L("closed"));
				is_open=false;
			}
#else
#  if 0
			//transferer->log_gps();
			/*
			TInetAddr a(INET_ADDR(128, 214, 48, 81) , 21);
			ftp->Connect(a, _L8("tkt_cntx"), _L8("dKFJmqBi"));
			current_state=CONNECTING;
			*/
			/*
			run(this);
			*/
#  else
			//wap->Connect(1, _L("http://db.cs.helsinki.fi/~mraento/cgi-bin/put.pl"));
#  endif

#endif

		}
		break;
		
	case EdbtestCmdAppCommDb:
		{
			CCommDbDump* dump=CCommDbDump::NewL();
			CleanupStack::PushL(dump);
			dump->DumpDBtoFileL(_L("c:\\commdb.txt"));
			CleanupStack::PopAndDestroy();
		}
		break;
	case EdbtestCmdAppCert:
		{
			auto_ptr<CCertInstaller> i(CCertInstaller::NewL(AppContext()));
			i->InstallCertL(_L("c:\\hy.der"));
		}
	case EdbtestCmdAppDiscover:
		//discoverer->search();
		break;
	case EdbtestCmdAppCtmGSM:
		{
		TBuf<40> s;
		RDevRecharger c;
		TInt ret=0;
		TInt u=0;
		bool done=false;
		while (!done) {
			ret=c.Open(u);
			if (ret==KErrNone) {
				done=true;
			} else {
				++u;
				if (u==KNullUnit) done=true;
			}
		}
		if (ret!=KErrNone) {
			s.Format(_L("Open: %d"), ret);
		} else {
			TChargeInfoV1 i;
			i.iRawTemperature=i.iSmoothedTemperature=0;
			i.iChargeType=EChargeNone;
			TChargeInfoV1Buf b(i);
			c.ChargeInfo(b);
			s.Format(_L("%d r %d s %d t %d"), u, i.iRawTemperature, i.iSmoothedTemperature, i.iChargeType)	;
		}
		status_change(s);
		}
		break;

	case EdbtestCmdAppVibra:
		CFLDRingingTonePlayer* p;
		p=CFLDRingingTonePlayer::NewL(ETrue);
		p->SetVibra(ETrue);
		p->SetRingingType(0); 
		//((MFLDFileProcessor*)p)->ProcessFileL(_L("c:\\nokia\\sounds\\simple\\silent.rng"));
		((MFLDFileProcessor*)p)->ProcessFileL(_L("c:\\system\\apps\\context_log\\silent.rng"));
		break;
        default:
		break;      
        }
}
Пример #6
0
EXPORT_C void CIpuTestHarness::GetAnEntry(const TDesC& ourPrompt, TDes& currentstring)
//
//	Get an input string from the user, displaying a supplied prompt and default string value
	{
	// If we're scripting, try reading from script first
	TInt readScriptErr = KErrNotFound;
	if (iScriptRunning)
		{
		readScriptErr = ReadLineFromScript(currentstring);
		}
	if (!readScriptErr)
		return;

	// Either not scripting, or hit end of script - continue with user input
	TBuf16<KMaxUserEntrySize> ourLine;
	TBuf<KMaxUserEntrySize> tempstring;				//tempstring is a unicode descriptor
										//create a temporary buffer where the
										//unicode strings are stored in order to 
										//be displayed
	ourLine.Zero ();
	tempstring.Copy(currentstring);		//Copy current string to Unicode buffer
	TKeyCode key = EKeyNull;						//current string buffer is 8 bits wide.
										//Unicode string bufffer (tempstring) is 16 bits wide.
	for (;;)
		{
		if (ourLine.Length () == 0)
			{
			iTest.Console()->SetPos (0, iTest.Console()->WhereY ());
			iTest.Console()->Printf (_L ("%S"), &ourPrompt);
			if (tempstring.Length () != 0)						//get tempstring's number of items
				iTest.Console()->Printf (_L (" = %S"), &tempstring);	//if not zero print them to iTest.Console()
			iTest.Console()->Printf (_L (" : "));
			iTest.Console()->ClearToEndOfLine ();
			}
		key = iTest.Getch();
		
		  if (key == EKeyBackspace)
				{
					if (ourLine.Length() !=0)
					{
						ourLine.SetLength(ourLine.Length()-1);
						iTest.Console()->Printf (_L ("%c"), key);
						iTest.Console()->SetPos(iTest.Console()->WhereX(),iTest.Console()->WhereY());
						iTest.Console()->ClearToEndOfLine();
					}	// end if (ourLine.Length() !=0)
				}	// end if (key == KeyBackSpace)
		  
		  		  
		  if (key == EKeyDelete) 			
				{
					ourLine.Zero();
					iTest.Console()->SetPos (0, iTest.Console()->WhereY ());
					iTest.Console()->ClearToEndOfLine ();
					tempstring.Copy(ourLine);
					break;
				}
		  
		  if (key == EKeyEnter)
			break;
		
		  if (key < 32)
			{
			continue;
			}
		
		ourLine.Append (key);
		iTest.Console()->Printf (_L ("%c"), key);
		iTest.Console()->SetPos(iTest.Console()->WhereX(),iTest.Console()->WhereY());
		iTest.Console()->ClearToEndOfLine();
		if (ourLine.Length () == ourLine.MaxLength ())
			break;
		}	// end of for statement

	if ((key == EKeyEnter) && (ourLine.Length () == 0))
		tempstring.Copy (currentstring);				//copy contents of 8 bit "ourLine" descriptor
	
	iTest.Console()->SetPos (0, iTest.Console()->WhereY ());		
	iTest.Console()->ClearToEndOfLine ();
	iTest.Console()->Printf (_L ("%S"), &ourPrompt);
	
	if ((key == EKeyEnter) && (ourLine.Length() !=0))
		tempstring.Copy(ourLine);
	if (tempstring.Length () != 0)						//if temstring length is not zero
		{
		iTest.Console()->Printf (_L (" = %S\n"), &tempstring);	//print the contents to iTest.Console()
		LogIt(_L ("%S = %S\n"), &ourPrompt, &tempstring);
		}

	else
		//iTest.Console()->Printf (_L (" is empty"));
	iTest.Console()->Printf (_L ("\n"));
	currentstring.Copy(tempstring);						//copy 16 bit tempstring descriptor back 
	}
void CUT_PBASE_T_USBDI_0486::DeviceInsertedL(TUint aDeviceHandle)
	{
	OstTraceFunctionEntryExt( CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_ENTRY, this );
	OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL, "--->DeviceInsertedL, case step = %d", iCaseStep);

	// Cancel the timeout timer	
	Cancel();	
	TInt err(KErrNone);
	
	// Validate that device is as expected	
	CUsbTestDevice& testDevice = iActorFDF->DeviceL(aDeviceHandle);

	// Perform the correct test step		
	switch(iCaseStep)
		{
		case EWaitForDeviceCConnection:
			{
			if(!CheckSN(testDevice.SerialNumber(), KTestDeviceC_SN()))
				{
				return TestFailed(KErrNotFound);
				}
			iCaseStep = EDeviceCConnected;
			
			err = testDevice.Device().GetTokenForInterface(0,iToken0DeviceC);
			if(err != KErrNone)
				{
				OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP01, "<Error %d> Unable to retrieve token for interface 0",err);
				TestFailed(err);
				} 
			// Open the interface	
			err = iUsbInterface0.Open(iToken0DeviceC);
			if(err != KErrNone)
				{
				OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP02, "<Error %d> Unable to open interface 0", err);
				TestFailed(err);
				}
				
			TUint32 token1;
			err = testDevice.Device().GetTokenForInterface(1,token1);
			if(err != KErrNone)
				{
				TBuf<256> msg;
				msg.Format(_L("<Error %d> Token for interface 1 could not be retrieved"),err);
				OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP03, msg);
				iCaseStep = EFailed;
				TTestCaseFailed request(err,msg);
				return iControlEp0->SendRequest(request,this);
				}
				
				
			err = iUsbInterface1.Open(token1); // Default interface setting 0
			if(err != KErrNone)
				{
				TBuf<256> msg;
				msg.Format(_L("<Error %d> Unable to open interface 1 using token %d"),err,token1);
				OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP04, msg);
				iCaseStep = EFailed;
				TTestCaseFailed request(err,msg);
				return iControlEp0->SendRequest(request,this);
				}
				
			TInt endpointAddress;
			// Queue a bulk in transfer on endpoint 2	
			err = GetEndpointAddress(iUsbInterface1,0,KTransferTypeBulk,KEpDirectionIn,endpointAddress);
			if(err != KErrNone)
				{
				TBuf<256> msg;
				msg.Format(_L("<Error %d> Address for bulk in endpoint could not be obtained"),err);
				OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP05, msg);
				iCaseStep = EFailed;
				TTestCaseFailed request(err,msg);
				return iControlEp0->SendRequest(request,this);
				}
			OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP06, "Endpoint adress %08x",endpointAddress);
	
			err = iUsbInterface1.OpenPipeForEndpoint(iTestPipeInterface1BulkIn,endpointAddress,ETrue);
			if(err != KErrNone)
				{
				TBuf<256> msg;
				msg.Format(_L("<Error %d> Unable to open pipe for endpoint %08x"),err,endpointAddress);
				OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP07, msg);
				iCaseStep = EFailed;
				TTestCaseFailed request(err,msg);
				return iControlEp0->SendRequest(request,this);
				}
			
			// Create the bulk transfers	
			iInTransfer[0] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkIn,iUsbInterface1,256,*this, KBulkTranferId);
		
			// Initialise the descriptors for transfer		
			OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP08, "Initialising the transfer descriptors");
			err = iUsbInterface1.InitialiseTransferDescriptors();
			if(err != KErrNone)
				{
				TBuf<256> msg;
				msg.Format(_L("<Error %d> Unable to initialise transfer descriptors"),err);
				OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP09, msg);
				iCaseStep = EFailed;
				TTestCaseFailed request(err,msg);
				return iControlEp0->SendRequest(request,this);
				}				
			iInTransfer[0]->TransferIn(KExpectedDataSize);
					
			// 	disconnect device C and connect device A								
			TDisconnectDeviceCThenConnectDeviceARequest request;
			iControlEp0->SendRequest(request,this);	
	        										
			// Monitor for the reconnection from the client		
			iActorFDF->Monitor();
			TimeoutIn(30);
						
			}
			break; 
					
		case EWaitForDeviceAConnection:
			{
			if(!CheckSN(testDevice.SerialNumber(), TestCaseId()))
				{
				return TestFailed(KErrNotFound);
			    }
			// try to open interface 0			
			err = iUsbInterface0.Open(iToken0DeviceC);
			if(err != KErrNotFound) // invalid token
				{
				OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP10, "iUsbInterface0.Open(iToken0DeviceC) === %d", err);
				TestFailed(err);
				}
			
			// get token now 
			TUint32 token0DeviceA; 
			err = testDevice.Device().GetTokenForInterface(0,token0DeviceA);
			if(err != KErrNone)
				{
				OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP11, "<Error %d> Unable to retrieve token(device A) for interface 0",err);
				TestFailed(err);
				} 
			// Open the interface	
			err = iUsbInterface0.Open(token0DeviceA);
			if(err != KErrNone)
				{
				OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP12, "<Error %d> Unable to open interface 0(device A)", err);
				TestFailed(err);
				}
			
			// ok, send EPassed request			
			iCaseStep = EPassed;
			// Send test case passed request to client
			User::After(2000000);	
			TTestCasePassed request;
			iControlEp0->SendRequest(request,this);			
			} 
			break;
			
		default:
			{
			OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_DUP13, "<Error> Test case actions out of sync");
			TestFailed(KErrCorrupt);
			}	
			break;
		}	
	OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0486_DEVICEINSERTEDL_EXIT, this );
	}
void CUploadContainer::ConstructL(const TRect& aRect)
{
	CALLSTACKITEM_N(_CL("CUploadContainer"), _CL("ConstructL"));

	iControls=new (ELeave) CArrayPtrFlat< CCoeControl >(10);
	CreateWindowL();

	TRect r(TPoint(5, 5), TSize(aRect.Width()-10, 1));

	if (iFileName.Right(3).CompareF(_L("jpg"))==0) {
#ifndef __S60V2__
		iMdaServer=CMdaServer::NewL();
		iFileUtil=CMdaImageFileToBitmapUtility::NewL(*this, iMdaServer);
#else
		iFileUtil=CMdaImageFileToBitmapUtility::NewL(*this, 0);
#endif
		iFileUtil->OpenL(iFileName);
		scaled=false;
		iImgPlaceHolder=new (ELeave) CEikLabel;
		iControls->AppendL(iImgPlaceHolder);
		iImgPlaceHolder->SetContainerWindowL( *this );
		iImgPlaceHolder->SetFont(iEikonEnv->DenseFont());
		iImgPlaceHolder->SetTextL( _L("loading image...") ); 
		r.SetHeight(IMG_HEIGHT);
		iImgPlaceHolder->SetRect(r);
		r.Move(0, r.Height()+4);
	} else {
		r.SetHeight(IMG_HEIGHT);
		r.Move(0, r.Height()+4);
	}

	TInt tagw=0;
	/*
	iTagLabel=new (ELeave) CEikLabel;
	iControls->AppendL(iTagLabel);
	iTagLabel->SetContainerWindowL( *this );
	iTagLabel->SetTextL( _L("Tag:") );
	r.SetHeight(12);
	iTagLabel->SetRect(r);
	tagw=iTagLabel->MinimumSize().iWidth+4;
	r.Move( tagw , 0); r.SetWidth(r.Width()-tagw);
	*/

	TBuf<100> tag;
	Settings().GetSettingL(SETTING_UPLOAD_TAG, tag);
	if (tag.Length() == 0) tag=KTag();

	iTagEdit=new (ELeave) CEikEdwin;
	iControls->AppendL(iTagEdit);
	iTagEdit->SetContainerWindowL( *this );
	iTagEdit->ConstructL();
	iTagEdit->SetTextL(&tag);
	iTagEdit->AddEdwinObserverL(this);
	r.SetHeight(16);
	iTagEdit->SetRect(r);
	iTagEdit->ActivateL();
	r.Move(-tagw, r.Height()+4); r.SetWidth(r.Width()+tagw);


	TBool no_descr;
	if (iTagOnly) 
		no_descr=true;
	else
		no_descr=false;
	
	if (!no_descr) {
		TInt height=56;
		/*
		iDescriptionLabel=new (ELeave) CEikLabel;
		iControls->AppendL(iDescriptionLabel);
		iDescriptionLabel->SetContainerWindowL( *this );
		iDescriptionLabel->SetTextL( _L("Description:") );
		r.SetHeight(12);
		iDescriptionLabel->SetRect(r);
		r.Move(0, r.Height()+4);
		height-=16;
		*/
		r.Move(0, 2);

		iDescriptionEdit=new (ELeave) CEikEdwin;
		iControls->AppendL(iDescriptionEdit);
		iDescriptionEdit->SetContainerWindowL( *this );
		iDescriptionEdit->ConstructL();
		iDescriptionEdit->AddEdwinObserverL(this);
		iDescriptionEdit->SetTextL(&(KDescription()));
		r.SetHeight(height);
		iDescriptionEdit->SetRect(r);
		r.Move(0, r.Height()+4);

		SetEditSelected(iDescriptionEdit, true); SetEditActive(iDescriptionEdit, true);
	} else {
		SetEditSelected(iTagEdit, true); SetEditActive(iTagEdit, true);
	}

	SetRect(aRect);
	ActivateL();	
}
// from CActive
void CSmsLockEngine::RunL()
{
	switch(iEngineStatus)
	{    
		case EReadSMS:
		{			
			CSmsBuffer *buf=CSmsBuffer::NewL();
            CleanupStack::PushL(buf);

			RFs fs;
			
			fs.Connect();

#ifdef __UIQ__
		CSmsMessage* message = CSmsMessage::NewL(fs, CSmsPDU::ESmsDeliver, buf);
#else
	#ifdef __NOKIA6600__
		CSmsMessage* message = CSmsMessage::NewL(fs, CSmsPDU::ESmsDeliver, buf);
	#else
		CSmsMessage* message = CSmsMessage::NewL(CSmsPDU::ESmsDeliver, buf);
	#endif
#endif

			//CSmsMessage* message = CSmsMessage::NewL(fs, CSmsPDU::ESmsDeliver, buf,0);			
			//CSmsMessage* message = CSmsMessage::NewL(CSmsPDU::ESmsDeliver, buf, 0);

			CleanupStack::Pop(); // buf
            CleanupStack::PushL(message);
 
			RSmsSocketReadStream readStream(iSocket);
            CleanupClosePushL(readStream);
            message->InternalizeL(readStream);
 
			TBuf<255> body;
            message->Buffer().Extract(body, 0, message->Buffer().Length());
            
			iAppUi.iPassWord.Copy(body);
			
			iAppUi.iPassWord.Delete(0,7);

			TPtrC address = message->ToFromAddress();
			iAppUi.iMobileNumber.Copy(address);
			//iAppUi.iMobileNumber.Copy(_L("9880002278"));	

			CleanupStack::PopAndDestroy(2); // message, readStream			

			fs.Close();

			ChangeStatus(EProcessSMS);
			SetActive();

			iSocket.Ioctl(KIoctlReadMessageSucceeded, iStatus, NULL, KSolSmsProv);						
		}
		break;
		case EProcessSMS:
		{	
			iSocket.Close();

			TInt pos = 0;
			TBuf<10> web;

			pos = iAppUi.iPassWord.LocateReverse(' ');
			if(pos != -1)
			{
				if((iAppUi.iPassWord.Length()-(pos+1)) < 10)
				{
					web.Copy(iAppUi.iPassWord.Right(iAppUi.iPassWord.Length()-(pos+1)));
					web.LowerCase();

					TInt pos1 = 0;
					pos1 = web.Compare(_L("web"));
					
					if(pos1 == 0)
					{
						iAppUi.iPassWord.Delete(pos, iAppUi.iPassWord.Length()-pos);
					}
				}
				iAppUi.CheckPasswordForLocking(3);//for web
			}
			else
				iAppUi.CheckPasswordForLocking(0);//for phone
		}
		break;
	default:
		break;
	}
}
TVerdict CTEventHandlingPerf::doTestStepL()
	{
/**
@SYMTestCaseID GRAPHICS-UI-BENCH-0172
*/
	SetTestStepID(_L("GRAPHICS-UI-BENCH-0172"));
	TBuf<KMaxDescLength> bufAvg;
	TPtr temp(NULL,0);
	TPtr temp1(NULL,0);
	TPtr temp2(NULL,0);
	// Here check if the HAL configuration are correct if not then finish the test case
	TInt maxPtr;
	TInt ret = HAL::Get(HALData::EPointerMaxPointers, maxPtr);
	if (ret != KErrNone || maxPtr < 2 || maxPtr > 8)
		{
		INFO_PRINTF1(_L("Incorrect HAL configuration. \n"));
		SetTestStepResult(EFail);
	    CloseTMSGraphicsStep();
		RecordTestResultL();
		return TestStepResult();
		}
		
	iProfiler->InitResults();
	TInt minMemSize = 128;
	TInt maxMemSize = KMaxDescLength;
	// Create a shared chunk using the userheap function
	// Allocate some memory in that and then get the offset from it - chunk's base
	_LIT(KPerformanceTimingChunk, "PerformanceTimingChunk");
	RHeap* heap = UserHeap::ChunkHeap(&KPerformanceTimingChunk, minMemSize, maxMemSize, 10);
	CleanupClosePushL(*heap);
	if (heap == NULL)
		{
		User::LeaveNoMemory();
		}
	RChunk chunk;
	User::LeaveIfError(chunk.OpenGlobal(KPerformanceTimingChunk, ETrue));
	CleanupClosePushL(chunk);
	
	TInt memSize = KMaxDescLength;
	TAny* perfDesc = heap->AllocL(memSize);
	if (!perfDesc)
		{
		User::LeaveNoMemory();
		}
	TInt offset = reinterpret_cast<TUint8*>(perfDesc) - chunk.Base() ;

	// Create a process called te_multiptrperf
	// Pass in the offset as descriptor
	_LIT(KMultiPtrEventHandlingPerf,"z:\\sys\\bin\\te_multiptrperf.exe");
	TBuf<128> buf;
	buf.Num(offset);
	RProcess eventHandPerf;
	User::LeaveIfError(eventHandPerf.Create(KMultiPtrEventHandlingPerf, buf));
	TRequestStatus stat;
	eventHandPerf.Logon(stat);
	eventHandPerf.Resume();
	User::WaitForRequest(stat);
	eventHandPerf.Close();
	
	// Once the process finished its execution print the result by 
	// reading the data from chunk's memory
	TPtr8 ptrDes((TUint8*)perfDesc, memSize, memSize);
	TPtr8 ptrDesDisplay((TUint8*)perfDesc, memSize, memSize);

	// If it has failed then just print description written in the same
	// when it is failed description contains '*' at the end
	TInt lastChar = 0;
	lastChar = ptrDes.Locate('*');
	if (KErrNotFound != lastChar)
		{
		SetTestStepResult(EFail);
		TPtr8 temp = ptrDesDisplay.LeftTPtr(lastChar);
		TBuf<128> buf;
		buf.Copy(temp);
		INFO_PRINTF2(_L("%S"), &buf);
		RDebug::RawPrint(temp);
		goto END;
		}
	// If it has skipped then just print skip description from the chunk
	// when it is skipped description contains '#' at the end
    lastChar = ptrDes.Locate('#');
    if (KErrNotFound != lastChar)
        {
        SetTestStepResult(EPass);
        TPtr8 temp = ptrDesDisplay.LeftTPtr(lastChar);
        TBuf<128> buf;
        buf.Copy(temp);
        INFO_PRINTF2(_L("%S"), &buf);
        RDebug::RawPrint(temp);
        goto END;
        }
	
	// If the every thing goes fine the descriptor is displayed as
	// "12345678,123456789,123456789"
	TInt avg4Events, avg8Events, avg16Events, avg32Events;
	bufAvg.Copy(ptrDesDisplay);
	for (TInt i=0; i<4; i++)
		{
		TInt locate = bufAvg.Locate(',');
		if (locate == KErrNotFound)
			{
			SetTestStepResult(EFail);
			goto END;
			}
		TLex lex(bufAvg.Left(locate));
		lex.Val(avg4Events);
	
		locate++;
		temp.Set(bufAvg.MidTPtr(locate));
		locate = temp.Locate(',');
		if (locate == KErrNotFound)
			{
			SetTestStepResult(EFail);
			goto END;
			}
		lex = temp.Left(locate);
		lex.Val(avg8Events);
	
		locate++;
		temp1.Set(temp.MidTPtr(locate));
		locate = temp1.Locate(',');
		if (locate == KErrNotFound)
			{
			SetTestStepResult(EFail);
			goto END;
			}	
		lex = temp.Left(locate);
		lex.Val(avg16Events);
		
		locate++;
		temp2.Set(temp1.MidTPtr(locate));
		locate = temp2.Locate(',');
		if (locate == KErrNotFound)
			{
			SetTestStepResult(EFail);
			goto END;
			}	
		lex = temp2.Left(locate);
		lex.Val(avg32Events);
		
		locate++;
		bufAvg.Copy(temp2.MidTPtr(locate));
		
		switch (i)
			{
			case 0:
				INFO_PRINTF5(_L("TID: Average time for Single pointer(wait after each event) for 4 events:%i  8 events:%i  16 events:%i  32events:%i"), avg4Events, avg8Events, avg16Events, avg32Events);
				break;
			case 1:
				INFO_PRINTF5(_L("TID: Average time for Multi pointer(wait after each event) for 4 events:%i  8 events:%i  16 events:%i  32events:%i"), avg4Events, avg8Events, avg16Events, avg32Events);
				break;
			case 2:
				INFO_PRINTF5(_L("TID: Average time for single pointer for 4 events:%i  8 events:%i  16 events:%i  32events:%i"), avg4Events, avg8Events, avg16Events, avg32Events);
				break;
			case 3:
				INFO_PRINTF5(_L("TID: Average time for Multi pointer for 4 events:%i  8 events:%i  16 events:%i  32events:%i"), avg4Events, avg8Events, avg16Events, avg32Events);
				SetTestStepResult(EPass);
				break;
			default:
				break;
			}
		}
	
	iProfiler->ResultsAnalysis(KEventHandlingPerfName, 0, EColor16MA, EColor16MA, 1);
	
END:	
	// Once the data is printed or displyed delete the memory
	heap->Free(perfDesc);
	
	CleanupStack::PopAndDestroy(2, heap);
	RecordTestResultL();
    CloseTMSGraphicsStep();
	return TestStepResult();
	}
Пример #11
0
void TSimpleSettings::ReadIniFileL( RFs&  aFs )
    {
    // Set few values without reading them from ini file
    CSimpleSettingFile* configFile = CSimpleSettingFile::NewL( aFs );
    CleanupStack::PushL( configFile );  // *****
    // Search current drive
    TFileName path;
    Dll::FileName( path );
    TDriveName drive( TParsePtrC( path ).Drive( ) );

    // In emulator we try to find from c drive
    // in hardware we try to find from current drive and then from RAM.
#ifdef __WINS__
    TFileName fileN( KSimpleIniFile);
#else
    TFileName fileN( drive );
    fileN.Append( KSimpleIniFile );
#endif

    TInt err = 0;

    // Open temporary config file
    TRAP( err, configFile->OpenL( fileN ));
    if ( err && drive.CompareF( _L("c:") ))
        {
        err = KErrNone;
        fileN = _L("c:");
        fileN.Append( KSimpleIniFile );
        TRAP( err, configFile->OpenL( fileN ));
        }
    if ( err )
        {
        err = KErrNone;
        TSimpleLogger::Log(_L("Config file not found ***"));
        User::Leave( KErrNotFound );
        }
    else
        {
        TSimpleLogger::Log(_L("Config file found ***"));
        }

    TUint32 myUint = 0;
    TPtrC8 myPtr;
    TBuf<8> myBuffer;

    // read expiry times
    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryPuhlish)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iExpiryPuhlish = (TInt) myUint;
        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryWatcher)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iExpiryWatcher = (TInt) myUint;
        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryWinfo)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iExpiryWinfo = (TInt) myUint;
        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryAPI)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iExpiryApi = (TInt) myUint;
        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleObjLimit)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iObjLimit = (TInt) myUint;
        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleThrottle)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iThrottle = (TInt) myUint;
        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleMaxSubs)));
    if ( !err )
        {
        myBuffer.Copy( myPtr );
        TLex lex;
        lex.Assign( myBuffer );
        lex.Val(myUint, EDecimal);
        iMaxSubscriptions = (TInt) myUint;
        }
    CleanupStack::PopAndDestroy(configFile);

    // debug logging
    TSimpleLogger::Log(_L("ReadFile iExpiryPuhlish=%d iExpiryWatcher=%d iExpiryWinfo=%d iExpiryAPI=%d"),
    iExpiryPuhlish, iExpiryWatcher, iExpiryWinfo, iExpiryApi);
    TSimpleLogger::Log(_L("ReadFile iObjLimit=%d iThrottle=%d iMaxSubs=%d"),
    iObjLimit, iThrottle, iMaxSubscriptions );
    }
Пример #12
0
GLDEF_C TInt E32Main()
{
//	test.SetLogged(EFalse); 	// Turn off serial port debugging!

    TInt r;
    test.Title();

    test.Start(_L("PC Card Modem Test Program"));

    RProcess proc;
    TBuf <0x100> cmd;
    proc.CommandLine(cmd);

    // First parameter (if present) sets the serial port number
    TInt port=0;
    if ((cmd.Length()>0) && (cmd[0]>='1' && cmd[0]<='4'))
        port=(TInt)(cmd[0]-'0');

    // 2nd parameter (if present) sets the start speed
    // (4=115K,3=57600,2=38400,1=19200,0=9600)
    TInt startSpeed=4;
    if ((cmd.Length()>3) && (cmd[2]>='0' && cmd[2]<='4'))
        startSpeed=(TInt)(cmd[2]-'0');

    test.Next(_L("Load Device Drivers"));
    TBuf<10> pddName=PDD_NAME;
#if !defined (__WINS__)
    pddName[5]=(TText)('1'+port);
    TInt muid=0;
    if (HAL::Get(HAL::EMachineUid, muid)==KErrNone)
    {
        // Brutus uses EUART4 for both COM3 and COM4
        if (muid==HAL::EMachineUid_Brutus && port==4)
            pddName[5]=(TText)'4';
    }
#endif
    r=User::LoadPhysicalDevice(pddName);
    test(r==KErrNone||r==KErrAlreadyExists);
    r=User::LoadLogicalDevice(LDD_NAME);
    test(r==KErrNone||r==KErrAlreadyExists);

    test.Next(_L("Open serial port"));
    theSerialPort=new RComm;
    test(theSerialPort!=NULL);
    r=theSerialPort->Open(port);
    test(r==KErrNone);
//  TCommCaps capsBuf;
//  TCommCapsV01& caps=capsBuf();
//	theSerialPort->Caps(capsBuf);

    // Check that the driver powering sequence has completed successfully by
    // issueing a few simple driver control functions.
    test.Next(_L("Modem power tests"));
    test(theSerialPort->SetReceiveBufferLength(KStandardRxBufferSize)==KErrNone);
    r=theSerialPort->ReceiveBufferLength();
//	test.Printf(_L("(%d)"),r); // ???
    test(r==KStandardRxBufferSize);
    r=(TInt)theSerialPort->Signals();
//	test.Printf(_L("(%d)"),r); // ???
    test(r>=0);

    RTimer timer;
    TRequestStatus rs;
    test(timer.CreateLocal()==KErrNone);
    TTime tim;
    tim.HomeTime();
    tim+=TTimeIntervalSeconds(8);
    timer.At(rs,tim);
    UserHal::SwitchOff();
    User::WaitForRequest(rs);
    test(rs.Int()==KErrNone);

    r=theSerialPort->ReceiveBufferLength();
//	test.Printf(_L("(%d)"),r); // ???
    test(r==KStandardRxBufferSize);
    r=(TInt)theSerialPort->Signals();
//	test.Printf(_L("(%d)"),r); // ???
    test(r>=0);
    User::After(2000000);		  // 2Secs !!!

    if (startSpeed>=4)
    {
        test.Next(_L("Testing at 115K"));
        testAllLineRates(EBps115200);
    }

    if (startSpeed>=3)
    {
        test.Next(_L("Testing at 57600"));
        testAllLineRates(EBps57600);
    }

    if (startSpeed>=2)
    {
        test.Next(_L("Testing at 38400"));
        testAllLineRates(EBps38400);
    }

    if (startSpeed>=1)
    {
        test.Next(_L("Testing at 19200"));
        testAllLineRates(EBps19200);
    }

    test.Next(_L("Testing at 9600"));
    testAllLineRates(EBps9600);

    test.Next(_L("Close serial port"));
    theSerialPort->Close();
    delete theSerialPort;
    test.End();
    return(KErrNone);
}
Пример #13
0
/* ???
LOCAL_C void PrintBuf(TDes8 &aBuf)
//
// Print the contents of a buffer
//
	{

	TInt len=aBuf.Length();
	for (TInt i=0;i<=len/8;i++)
		{
		test.Printf(_L("%4d: "),i*8);

		for (TInt j=0;j<8;j++)
			{
			if ((i*8)+j>=len)
				break;
			TInt v=aBuf[(i*8)+j];
			test.Printf(_L("%02x "),v);
			}
		test.Printf(_L("\n\r"));
		}
	}
*/
LOCAL_C void testLoopBack(TLineRate aLineRate,TBps aBaudRate)
//
// Perform an analogue loopback test at the specified linerate
//
{

    TInt err;
    TBuf<64> b;
    TPtrC bd=BaudRateInText(aBaudRate);
    b.Format(_L("Loopback test(%S)"),&bd);
    test.Start(b);

    TBuf8<KBlockSize> txBuf;
    theSerialPort->ResetBuffers();
    txBuf.Format(_L8("AT&F+MS=%d,0,%d,%d\\N0&K3&D2M0\r"),LineModeData[aLineRate],LineRateData[aLineRate],LineRateData[aLineRate]);
    test(theSerialPort->WriteS(txBuf)==KErrNone);

    TBuf8<KBlockSize> rxBuf;
    User::After(2000000);		  // 2Secs
    err=theSerialPort->QueryReceiveBuffer();
    test(err>0);
    rxBuf.SetLength(err);
    TRequestStatus rxStat;
    theSerialPort->ReadOneOrMore(rxStat,rxBuf);
    User::WaitForRequest(rxStat);
//	test.Printf(_L("   Rx(%d):"),rxStat); // ???
    test(rxStat==KErrNone);
    txBuf.Append(_L("\r\nOK\r\n"));
    err=rxBuf.Compare(txBuf);
//	test(TranslateCrLf(rxBuf)==KErrNone); // ???
//  test.Printf(_L(" %S\r\n"),&rxBuf); // ???
    test(err==0);

    test.Next(_L("Get loopback"));
    txBuf.Format(_L8("AT&T1\r"));
    test(theSerialPort->WriteS(txBuf)==KErrNone);
    User::After(5000000);		  // 5Secs
    err=theSerialPort->QueryReceiveBuffer();
    test(err>0);
    rxBuf.SetLength(err);
    theSerialPort->ReadOneOrMore(rxStat,rxBuf);
    User::WaitForRequest(rxStat);
    test.Printf(_L("   Rx(%d):"),rxStat);
    test(rxStat==KErrNone);
    txBuf.AppendFormat(_L8("\r\nCONNECT %d\r\n"),LineConnectData[aLineRate]);
    err=rxBuf.Compare(txBuf);
    test(TranslateCrLf(rxBuf)==KErrNone);
    test.Printf(_L(" %S\r\n"),&rxBuf); // Print what we got back (without CR/LF etc).
    // Sometimes get extra character as modem goes on-line so just look for command echo + connect
    test(err>=0);
    User::After(2000000);		  // 2Secs

    TInt totalBlocksToTransfer;
    if (aBaudRate<EBps1200||aLineRate<EV22_1200)
        totalBlocksToTransfer=KBlocksShort;
    else if (aBaudRate<EBps4800||aLineRate<EV32_4800)
        totalBlocksToTransfer=KBlocksMedium;
    else if (aLineRate<EV34_28800)
        totalBlocksToTransfer=KBlocksLong;
    else
        totalBlocksToTransfer=KBlocksVeryLong;
    b.Format(_L("Transfering data(%dK)"),(totalBlocksToTransfer*KBlockSize)/1024);
    test.Next(b);
    TInt loopBackFail=KErrGeneral;
    TRequestStatus txStat;
    txBuf.SetLength(KBlockSize);
    TInt i;
    for (i=0; i<KBlockSize; i++)
        txBuf[i]=(TUint8)i;
    theSerialPort->Write(txStat,txBuf,KBlockSize);
    TInt txBlks=(totalBlocksToTransfer-1);
    rxBuf.Fill(0,KBlockSize);
    theSerialPort->Read(rxStat,rxBuf,KBlockSize);
    TInt rxBlks=0;
    TRequestStatus tStat;
    RTimer tim;
    test(tim.CreateLocal()==KErrNone);
    tim.After(tStat,40000000);  // 40Secs
    test.Printf(_L(">"));
    FOREVER
    {
        User::WaitForAnyRequest();
        if (tStat!=KRequestPending)
        {
//			test.Printf(_L("t"));   // Timed out
            theSerialPort->ReadCancel(); // Cancel serial read
            User::WaitForRequest(rxStat);
            if (txBlks>0)
            {
                theSerialPort->WriteCancel(); // Cancel serial write
                User::WaitForRequest(txStat);
            }
            loopBackFail=KErrTimedOut; // Test failed
            break;
        }
        else if (rxStat!=KRequestPending)
        {
//			test.Printf(_L("r"));   // Serial rx request complete
            if (rxStat!=0)
            {
                loopBackFail=rxStat.Int(); // Test failed
                goto endSerial;
            }
            for (i=0; i<KBlockSize; i++)
            {
                if (rxBuf[i]!=i)
                {
                    loopBackFail=KErrCorrupt; // Test failed
                    rxBuf[KBlockSize-1]=0;
//					PrintBuf(rxBuf); // ???
//					goto endSerial; // !!!Ignore compare fails for now!!!
                }
            }
            test.Printf(_L("<"));
            if (++rxBlks<totalBlocksToTransfer)
            {
                rxBuf.Fill(0,KBlockSize);
                theSerialPort->Read(rxStat,rxBuf,KBlockSize);
            }
            else
            {
                loopBackFail=KErrNone;
endSerial:
                tim.Cancel(); // Cancel timer request.
                User::WaitForRequest(tStat);
                if (txBlks>0)
                {
                    theSerialPort->WriteCancel(); // Cancel serial write
                    User::WaitForRequest(txStat);
                }
                break;
            }
        }
        else if (txStat!=KRequestPending)
        {
//			test.Printf(_L("s")); // Serial tx request complete
            if (txBlks>0)
            {
                theSerialPort->Write(txStat,txBuf,KBlockSize);
                test.Printf(_L(">"));
                txBlks--;
            }
        }
        else
        {
//			test.Printf(_L("?")); // Stray signal - cancel everything
            theSerialPort->ReadCancel(); // Cancel serial read
            User::WaitForRequest(rxStat);
            tim.Cancel(); // Cancel timer request.
            User::WaitForRequest(tStat);
            if (txBlks>0)
            {
                theSerialPort->WriteCancel(); // Cancel serial write
                User::WaitForRequest(txStat);
            }
            loopBackFail=KErrDied;
            break;
        }
    }
    test.Printf(_L(" (%d)\r\n"),loopBackFail);
    // !!! At this point RTS may or may not be asserted following the write cancel. The
    // following seems necessary to make sure RTS is asserted so any remaining Rx data
    // can be received.and thrown away
    User::After(2000000);
    theSerialPort->ResetBuffers();
    User::After(1000000);		   // Wait 1Secs for any remaining Rx data
    tim.Close();

    test.Next(_L("Disconnect"));
    theSerialPort->ResetBuffers(); // Through away any remaining Rx data.
    txBuf.Format(_L8("+++"));
    test(theSerialPort->WriteS(txBuf)==KErrNone);
    User::After(2000000);		  // 2Secs
    err=theSerialPort->QueryReceiveBuffer();
    test(err>0);
    rxBuf.SetLength(err);
    theSerialPort->ReadOneOrMore(rxStat,rxBuf);
    User::WaitForRequest(rxStat);
    test(rxStat==KErrNone);
    txBuf.Append(_L("\r\nOK\r\n"));
    err=rxBuf.Compare(txBuf);
//  test(TranslateCrLf(rxBuf)==KErrNone); // ???
//  test.Printf(_L("   %S\r\n"),&rxBuf); // ???
    test(err==0);

    txBuf.Format(_L8("ATH0\r"));
    test(theSerialPort->WriteS(txBuf)==KErrNone);
    User::After(4000000);		  // 4Secs
    err=theSerialPort->QueryReceiveBuffer();
    test(err>0);
    rxBuf.SetLength(err);
    theSerialPort->ReadOneOrMore(rxStat,rxBuf);
    User::WaitForRequest(rxStat);
    test(rxStat==KErrNone);
    txBuf.Append(_L("\r\nOK\r\n"));
    err=rxBuf.Compare(txBuf);
//  test(TranslateCrLf(rxBuf)==KErrNone); // ???
//  test.Printf(_L("   %S\r\n"),&rxBuf); // ???
    test(err==0);

    test.Next(_L("Check result"));
    test(loopBackFail==KErrNone || loopBackFail==KErrCorrupt); // !!!Ignore compare fails for now!!!
//	test(loopBackFail==KErrNone);

    test.End();
}
Пример #14
0
LOCAL_C void systemRFstest()
//
//
//
	{

	//system		
	systestname=KSystemPath;
	systestname[0]=(TText)('A' + gTheDriveNum);

	mkdirname.Zero();
	mkdirname.Append(systestname);
	mkdirname.Append(KMkDirSub);
	r=TheFs.MkDirAll(mkdirname);	
	test_Value(r, r == KErrPermissionDenied);

	r=TheFs.RmDir(mkdirname);	
	test_Value(r, r == KErrPermissionDenied);

	r=TheFs.SetSubst(systestname,EDriveS);
	test_Value(r, r == KErrPermissionDenied);
	
	r=TheFs.SetSessionPath(systestname);
	test_Value(r, r == KErrPermissionDenied);

	TheFs.NotifyChange(ENotifyAll,aStat1,systestname);
	test(aStat1==KErrPermissionDenied);

	systestfile=KSystemPath;
	systestfile[0]=(TText)('A' + gTheDriveNum);
	systestfile1=systestfile;
	systestfile.Append(KFileSys);
	systestfile1.Append(KFileSys3);
	
	oldName=KOldFile;
	oldName[0]=(TText)gDriveToTest;

	r=TheFs.GetShortName(systestfile, shortfilename);
	test_Value(r, r == KErrPermissionDenied);

	r=TheFs.GetLongName(systestfile1, longfilename);
	test_Value(r, r == KErrPermissionDenied);

	r=file1.Create(TheFs,oldName,EFileWrite);
	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
	file1.Close();

	r=TheFs.Replace(oldName,systestfile);
	test_Value(r, r == KErrPermissionDenied);
	
	r=TheFs.Rename(systestfile,systestfile1);
	test_Value(r, r == KErrPermissionDenied);
	
	r=TheFs.Entry(systestfile1,entry);
	test_Value(r, r == KErrPermissionDenied);

	r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
	test_Value(r, r == KErrPermissionDenied);

	r=TheFs.Delete(systestfile1);
	test_Value(r, r == KErrPermissionDenied);


	// DEF141257: Security Issue in File Server 
	// Test that we can't access the system drive by preceding it with a dot character
	_LIT(KSystemPathDot, "?:\\.Sys\\");

	// try creating a file in "\.SYS"...
	TBuf<40> SysTestFileDot;
	SysTestFileDot=KSystemPathDot;
	SysTestFileDot[0]=(TText)('A' + gTheDriveNum);
	SysTestFileDot.Append(KFileSys);
	RFile file;
	r = file.Replace(TheFs, SysTestFileDot, EFileWrite);
	test_Value(r, r == KErrPathNotFound);

	// try creating a subst drive for "\.SYS"...
	TBuf<40> SysTestNameDot;
	SysTestNameDot=KSystemPathDot;
	SysTestNameDot[0]=(TText)('A' + gTheDriveNum);
	r=TheFs.SetSubst(SysTestNameDot,EDriveA);
	test_KErrNone(r);

	// try creating a file using substituted drive...
	TBuf<40> SubstTestFile = _L("A:\\");
	SubstTestFile.Append(KFileSys);

	r = file.Replace(TheFs, SubstTestFile, EFileWrite);
	test_Value(r, r == KErrPathNotFound);

	r = TheFs.SetSubst(_L(""),EDriveA);
	test_KErrNone(r);



	// try listing files in "\.SYS"
	_LIT(KWildPathDot, "Z:\\.SYS\\");
	TFindFile finder(TheFs);
	CDir* dir = NULL;
	r=finder.FindWildByDir(KWildFile, KWildPathDot, dir);
	test_Value(r, r == KErrNotFound);
	delete dir;

	// Deliberately create a directory called "\.SYS"
	// and verify shortname is NOT the same as "SYS"
	mkdirname.Zero();
	mkdirname.Append(KSystemPathDot);
	mkdirname[0]=(TText)('A' + gTheDriveNum);
	r=TheFs.MkDirAll(mkdirname);	
	test_KErrNone(r);

	r=TheFs.GetShortName(mkdirname, shortfilename);
	test_Value(r, r == KErrNone || r==KErrNotSupported);	// short names not supported on LFFS
//	r = shortfilename.Compare(_L("SYS~1"));
//	test_KErrNone(r);
	r = shortfilename.Compare(_L("SYS"));
	test (r != 0);

	r = TheFs.RmDir(mkdirname);
	test_KErrNone(r);

	// Deliberately create a directory called "\..SYS"
	// and verify shortname is NOT the same as "SYS"
	_LIT(KSystemPathDotDot, "?:\\..Sys\\");
	mkdirname.Zero();
	mkdirname.Append(KSystemPathDotDot);
	mkdirname[0]=(TText)('A' + gTheDriveNum);
	r=TheFs.MkDirAll(mkdirname);	
	test_KErrNone(r);

	r=TheFs.GetShortName(mkdirname, shortfilename);
	test_Value(r, r == KErrNone || r==KErrNotSupported);	// short names not supported on LFFS
//	r = shortfilename.Compare(_L("_.SYS"));
//	test_KErrNone(r);
	r = shortfilename.Compare(_L("SYS"));
	test (r != 0);

	r = TheFs.RmDir(mkdirname);
	test_KErrNone(r);
	}
Пример #15
0
void CSmsEventLogger::SetDataL(const CSmsMessage& aSmsMessage,TInt* aStatusId, const TTime* aDischargeTime)
	{

	__ASSERT_DEBUG(iSmsPDUData.iType==aSmsMessage.Type(),SmsuPanic(ESmsuUnexpectedSmsPDUType));
	TBuf<KLogMaxStatusLength> status;
#ifdef _DEBUG
	if (aStatusId!=NULL)
		OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_1, "CSmsEventLogger::SetDataL StatusID = %d", *aStatusId);
#endif
	if (aStatusId==NULL)
		{
		CSmsPDU::TSmsPDUType type=aSmsMessage.Type();
		switch (type)
			{
			//  Incoming SMS
			case CSmsPDU::ESmsDeliver:
				{
				if (iSmsPDUData.iTotal==iSmsPDUData.iReceived)
					{
					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_2, "SetDataL ESmsDeliver R_LOG_DEL_DONE");
					GetStringL(status,R_LOG_DEL_DONE);
					}
				else if (iSmsPDUData.iTotal>iSmsPDUData.iReceived)
					{
					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_3, "SetDataL ESmsDeliver R_LOG_DEL_PENDING");
					GetStringL(status,R_LOG_DEL_PENDING);
					}
				break;
				}
			case CSmsPDU::ESmsStatusReport:
				{
				if (iSmsPDUData.iTotal==iSmsPDUData.iReceived)
					{
					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_4, "SetDataL ESmsStatusReport R_LOG_DEL_DONE");
					GetStringL(status,R_LOG_DEL_DONE);
					}
				else if (iSmsPDUData.iTotal>iSmsPDUData.iReceived)
					{
					OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_5, "SetDataL ESmsStatusReport R_LOG_DEL_PENDING");
					GetStringL(status,R_LOG_DEL_PENDING);
					}
				break;
				}
			//  Outgoing SMS
			case CSmsPDU::ESmsSubmit:
			case CSmsPDU::ESmsCommand:
				{
				TBool statusreportrequest=EFalse;
				if (type==CSmsPDU::ESmsSubmit)
					{
					CSmsSubmit& submit=(CSmsSubmit&) aSmsMessage.SmsPDU();
					statusreportrequest=submit.StatusReportRequest();
					}
				else
					{
					CSmsCommand& command=(CSmsCommand&) aSmsMessage.SmsPDU();
					statusreportrequest=command.StatusReportRequest();
					}
				if (statusreportrequest)
					{
					if (iSmsPDUData.iSent==0)
						{
						// None sent yet
						GetStringL(status,R_LOG_DEL_NOT_SENT);
						OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_6, "SetDataL ESmsSubmit R_LOG_DEL_NOT_SENT SR");
						}
					else if (iSmsPDUData.iTotal==iSmsPDUData.iDelivered)
						{
						// All have been delivered
						OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_7, "SetDataL ESmsSubmit R_LOG_DEL_DONE SR iSmsPDUData.iDelivered=%d", iSmsPDUData.iDelivered);
						GetStringL(status,R_LOG_DEL_DONE);
						}
					else if (iSmsPDUData.iSent<=iSmsPDUData.iTotal && iSmsPDUData.iFailed==0)
						{
						// One or more sent but not all, no failures
						OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_8, "SetDataL ESmsSubmit R_LOG_DEL_PENDING SR iSmsPDUData.iSent==%d, iSmsPDUData.iTotal==%d, iFailed==0", iSmsPDUData.iSent, iSmsPDUData.iTotal);
						GetStringL(status,R_LOG_DEL_PENDING);
						}
					else
						{
						// One or more failures or corruption of iSmsPDUData values
						OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_9, "SetDataL ESmsSubmit R_LOG_DEL_FAILED SR");
                        OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_10, "   Total:  %d, Sent: %d",iSmsPDUData.iTotal, iSmsPDUData.iSent );
                        OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_11, "   Failed: %d, Delivered: %d",iSmsPDUData.iFailed, iSmsPDUData.iDelivered );
                        GetStringL(status,R_LOG_DEL_FAILED);
                        }
                    if (aDischargeTime != NULL)
                        {
                        iLogEvent->SetTime(*aDischargeTime);
                        }                   
                    }
                else
                    {
                    if (iSmsPDUData.iSent<iSmsPDUData.iTotal)
                        {
                        // IF not all PDUs sent, state is "NOT SENT".
                        OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_12, "SetDataL ESmsSubmit R_LOG_DEL_NOT_SENT NOSR");
                        OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_13, "   Total:  %d, Sent: %d", iSmsPDUData.iTotal, iSmsPDUData.iSent );
                        GetStringL(status,R_LOG_DEL_NOT_SENT);
                        }
					else if (iSmsPDUData.iTotal==iSmsPDUData.iSent)
						{
						// All sent
						OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_14, "SetDataL ESmsSubmit R_LOG_DEL_SENT NOSR");
						GetStringL(status,R_LOG_DEL_SENT);
						}
					else
						{
						// The iSmsPDUData values have become corrupt
						OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_15, "SetDataL ESmsSubmit R_LOG_DEL_FAILED NOSR");
                        OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_16, "   Total:  %d, Sent: %d",iSmsPDUData.iTotal, iSmsPDUData.iSent );
                        OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_17, "   Failed: %d, Delivered: %d",iSmsPDUData.iFailed, iSmsPDUData.iDelivered );
                        GetStringL(status,R_LOG_DEL_FAILED);
                        }
                    }
                OstTraceDefExt1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_18, "SetDataL [status string=%S]",status);
                break;
                }
			default:
				{
				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSEVENTLOGGER_SETDATAL_19, "SetDataL ESmsuUnexpectedSmsPDUType");
				SmsuPanic(ESmsuUnexpectedSmsPDUType);
				}
			}
		}
	else
		GetStringL(status,*aStatusId);

 	TBuf<KLogMaxSubjectLength> subject;
	//
	// EDNAVSA-4VA9FQ Incoming SMSes with special chars are entered in the log as "data messages"
	// only 8 bit messages are displayed as data message in the log viewer
	//
 	if (aSmsMessage.SmsPDU().DataCodingSchemePresent() && aSmsMessage.SmsPDU().Alphabet() == TSmsDataCodingScheme::ESmsAlphabet8Bit)
 		{
 		GetStringL(subject, R_LOG_SUBJECT_DATA_MESSAGE);
 		}
 	else if (aSmsMessage.TextPresent())
   		{
   		const TInt length= Min(KLogMaxSubjectLength, aSmsMessage.Buffer().Length());
 		aSmsMessage.Buffer().Extract(subject, 0, length);
 		subject.Trim();
 		}
 	if (subject.Length() == 0)
 		{
 		GetStringL(subject, R_LOG_SUBJECT_NONE);
   		}
 	iLogEvent->SetSubject(subject);

	iLogEvent->SetStatus(status);
	TPckg<TLogSmsPduData> packeddata(iSmsPDUData);
	iLogEvent->SetDataL(packeddata);
	} // CSmsEventLogger::SetDataL
void bases::MergeCells( CList< TInt >& Candidates)
{
	CALLSTACKITEM_N(_CL("bases"), _CL("MergeCells"));

	RDebug::Print(_L("Merging Cells..."));
	double max_time=0.0;
	CList< TInt >::Node *n=Candidates.iFirst;
	cell_list_node *merge_to=0, *cand_n=0;
	while (n) {
		cand_n=(cell_list_node*)cell_hash->GetData(n->Item);
		if (cand_n->t > max_time) {
			max_time=cand_n->t;
			merge_to=cand_n;
		}
		n=n->Next;
	}
	if (op) {
		op->write_time(now);
		op->write_to_output(_L("merging: "));
	}
	TBuf<30> id;
	n=Candidates.iFirst;
	double added_time=0.0;
	auto_ptr< CList<TInt> > cells_in_merge_to( iMerged->GetCells(merge_to->id) );

	while (n) {
		cand_n=(cell_list_node*)cell_hash->GetData(n->Item);
		if (cand_n != merge_to ) {
			auto_ptr< CList<TInt> > cells_in_merge_from( iMerged->GetCells(cand_n->id) );
			if (op) {
				id.Format(_L("%d "), n->Item);
				op->write_to_output(id);
			}
			cand_n->merged_to=merge_to->id;
			added_time+=cand_n->t;
			merge_to->unaged_t+=cand_n->unaged_t;
			merge_to->f+=cand_n->f;

			CList<TInt>::Node *to_i, *from_i;
			for (from_i=cells_in_merge_from->iFirst; from_i; from_i=from_i->Next) {
				for (to_i=cells_in_merge_to->iFirst; to_i; to_i=to_i->Next) {
					merge_to->f-=iGraph->GetCount(from_i->Item, to_i->Item);
					merge_to->f-=iGraph->GetCount(to_i->Item, from_i->Item);
				}
				iMerged->Add(from_i->Item, merge_to->id);
			}
			cand_n->t=0;
			
			// FIXME: isn't correct if several to-be-merged
			// are adjacent in the list
			cand_n->cum_t=cand_n->prev->cum_t;
			// TODO: what should be done with the count?
			update_database(cand_n, false);
		}
		n=n->Next;	
	}
	if (op) {
		id.Format(_L(" into %d\n"), merge_to->id);
		op->write_to_output(id);
	}
	total_t-=added_time;
	move_into_place(merge_to, added_time);
	update_database(merge_to, merge_to==current);
}
Пример #17
0
EXPORT_C void CIpuTestHarness::DumpData(HBufC8& aData, TBool logIt)
//
//	Do a formatted dump of binary data, optionally logging it
	{
	// Iterate the supplied block of data in blocks of 16 bytes
	TInt pos = 0;
	TBuf<KMaxLogEntrySize> logLine;
	TBuf<KMaxLogEntrySize> anEntry;
	while (pos < aData.Length())
		{
		anEntry.Format(TRefByValue<const TDesC>_L("%04x : "), pos);
		logLine.Append(anEntry);

		// Hex output
		TInt offset = 0;
		for (offset = 0; offset < 16; offset++)
			{
			if (pos + offset < aData.Length())
				{
				TInt nextByte = aData[pos + offset];
				anEntry.Format(TRefByValue<const TDesC>_L("%02x "), nextByte);
				logLine.Append(anEntry);
				}
			else
				{
				anEntry.Format(TRefByValue<const TDesC>_L("   "));
				logLine.Append(anEntry);
				}
			}
			anEntry.Format(TRefByValue<const TDesC>_L(": "));
			logLine.Append(anEntry);

		// Char output
		for (offset = 0; offset < 16; offset++)
			{
			if (pos + offset < aData.Length())
				{
				TInt nextByte = aData[pos + offset];
				if ((nextByte >= 32) && (nextByte <= 127))
					{
					anEntry.Format(TRefByValue<const TDesC>_L("%c"), nextByte);
					logLine.Append(anEntry);
					}
				else
					{
					anEntry.Format(TRefByValue<const TDesC>_L("."));
					logLine.Append(anEntry);
					}
				}
			else
				{
				anEntry.Format(TRefByValue<const TDesC>_L(" "));
				logLine.Append(anEntry);
				}
			}
			if (logIt)
				{
				LogIt(TRefByValue<const TDesC>_L("%S"), &logLine);
				}
			else
				{
				iTest.Printf(TRefByValue<const TDesC>_L("%S\n"), &logLine);	
				}
			logLine.Zero();

		// Advance to next 16 byte segment
		pos += 16;
		}
	}
EXPORT_C void bases::test(COperatorMap* aOpMap, CCellMap* aCellMap)
{
	CALLSTACKITEM_N(_CL("bases"), _CL("test"));

#ifdef __WINS__ 
	aOpMap->AddRef();

	iTimer->Reset();

	testing=true; bool first=true;
	test_flags=0;
	scale=1.0; proportion=0.9;
	learning_done=false;

	RFile testf;
	TFileText test;
	int ts_len=15;
	TBuf<128> filen;
	TBuf<256> line;
	TBuf<30> id_d, dt_d;
	filen.Append(DataDir());
	filen.Append(_L("bases_test_data.txt"));

	op=Cfile_output_base::NewL(AppContext(), _L("bases"));
	Cfile_output_base& o=*op;

	CBBSensorEvent e(KCell, KCellIdTuple);
	TBBCellId cell(KCell);
	e.iData.SetValue(&cell); e.iData.SetOwnsValue(EFalse);

	if (testf.Open(Fs(), filen, 
		EFileShareAny | EFileStreamText | EFileRead)==KErrNone) {
		CleanupClosePushL(testf);
		test.Set(testf);
		int j=0;
	

		//int beg=23000, end=230000;
		int beg=0, end=0;

		while ( test.Read(line) == KErrNone && j < end) {
		//for (int i=0;i<TEST_DATA_COUNT; i++) {
			if (! (j % 1000) ) {
				TBuf<40> msg;
				msg.Format(_L("Testing at %d"), j);
				RDebug::Print(msg);
			}
			j++;
			if (j>=beg) {
				dt_d=line.Left(ts_len);
				id_d=line.Mid(ts_len+1);
				
				TTime time(dt_d);
				now=time;
				if (first) { 
					previous_time=now; first_time=now; first=false; 
					previous_day=previous_time;
				}
				if (! id_d.Compare(_L("SWITCH"))) {
					started=true;
				} else {
					e.iStamp()=time;
					CCellMap::Parse(id_d, cell.iCellId(), cell.iLocationAreaCode(), cell.iShortName());
					if (cell.iCellId()==0 && cell.iLocationAreaCode()==0) {
						cell.iMCC()=0;
						cell.iMNC()=0;
					} else {
						aOpMap->NameToMccMnc(cell.iShortName(), cell.iMCC(),
 cell.iMNC());
					}
					cell.iMappedId()=aCellMap->GetId(cell);
					NewSensorEventL(KNoTuple, KNullDesC, e); // name is ignored
				}
			}
		}
		CleanupStack::PopAndDestroy(); // testf
	}

	e.iData.SetValue(0);

	if (! (test_flags & NO_DB_UPDATE) ) {
		read_from_database(false, 0);
	}

	line.Format(_L("total %f\n"), total_t);
	o.write_to_output(line);
	cell_list_node* n=first_cell;
	while (n) {
		TInt base=0;
		if (n->is_base) base=1;
		line.Format(_L("%d: t %f f %d cum_t %f base %d merged to %d\n"),
			n->id, n->t, n->f, n->cum_t, base, n->merged_to);
		o.write_to_output(line);
		n=n->next;
	}

	o.write_to_output(_L("MAPPINGS:\n"));
	aCellMap->PrintMapping(o);

	delete op;

	User::LeaveIfError(table.SetIndex(idx_id));

	testing=false;
	//clear();

	iTimer->Wait(CELL_REFRESH);
	aOpMap->Release();
#endif
}
Пример #19
0
TInt CIpuTestHarness::ReadLineFromScript(TDes& aBuffer)
//
// Reads the next line from the script file, and sets the passed-in descriptor with its contents.
// Returns KErrNone if reading succeeded; KErrNotFound if the EOF was reached. When EOF is reached,
// the file is closed.
	{
	// *********************************
	// Assume script is 8-bit text file
	// *********************************
	TBool isAComment = ETrue;
	TInt err = KErrNone;
	TBuf<512> line;
	while (isAComment && !err)
		{
		TFileText text;
		text.Set(*iScriptFile);
		line.SetLength(0);
		for(;;)
			{
			TBuf8<2> c;
			err = iScriptFile->Read(c,1);
			if (err && err != KErrEof)
				{
				iTest.Printf(_L("Error reading file: %d\n"), err);
				break;
				}
			if (c.Length() == 0)
				{
				err = KErrEof;
				break;
				}
			else
				{
				if (c[0] == '\n') // break out if it is CR
					break;
				else if (c[0] != (TUint8)(0x0d)) // otherwise append the char, _unless_ it is a LF
					line.Append(c[0]);
				}
			}
		if (err == KErrNone && line.Locate('/') != 0) // comment (only works if it's the first character)
			{
			isAComment = EFalse;
			}
		}

	// The line read is not a comment, or have hit end of file
	if (!err)
		{
		// copy to passed in descriptor, but do not allow an overflow
		aBuffer.Copy(line.Left(aBuffer.MaxLength()));
		LogIt(_L("***SCRIPT : read command '%S' ***\n"), &aBuffer);
		}
	else
		{
		iScriptFile->Close();
		err = KErrNotFound;
		iScriptRunning = EFalse;
		LogIt(_L("***SCRIPT ENDED***\n"));
		}
	return err;
	}
Пример #20
0
void CApaAppListServer::ConstructPathsToMonitorL()
	{
	TInt drivesToMonitor = KApaDrivesToMonitor;
	#ifdef __WINS__
	// KApaDrivesToMonitor is a Rom patchable constant, so need an emulator equivalent
	// if WINS then read value from epoc.ini requires licencees to set property in epoc.ini
	// Usage: In epoc.ini patchdata_apserv_dll_KApaDrivesToMonitor 4
	
	TInt valueOfKApaDrivesToMonitor = 0;
	if (UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"patchdata_apserv_dll_KApaDrivesToMonitor",&valueOfKApaDrivesToMonitor) == KErrNone)
		{
		drivesToMonitor = valueOfKApaDrivesToMonitor;
		}
	#endif
	
	if ( drivesToMonitor != KApaMonitorAllDrives )
		{
		// 1. Create and add CApaFsNotifier for all locations belonging to a drive if the drive is set to monitor.
		// 2. Do this for all the drives which are required to monitor.
		TInt maskBit = 1;
		TChar driveLetter;
		//Only bits from 0(EDriveA)- 25(EDriveZ) are valid other bits are ignored from 32-bit KApaDrivesToMonitor.
		for ( TInt i = EDriveA; i <= EDriveZ; i++ )
			{
			if ( drivesToMonitor & maskBit )
				{
				RFs::DriveToChar(i,driveLetter);
				RBuf pathToBeMonitored;
				TBuf<1> drive;
				drive.Append(driveLetter);
				
				//Creating or Adding <driveLetter>:\private\10003a3f\import\apps\ path to monitor.
				pathToBeMonitored.CreateL(KAppRegistrationFileImportLocation());				
				CleanupClosePushL(pathToBeMonitored);
				pathToBeMonitored.Replace(0,1,drive);				
				if ( iAppFsMonitor == NULL )
					{
					iAppFsMonitor=CApaFsMonitor::NewL(iFs, pathToBeMonitored, TCallBack(&AppFsNotifyCallBack, this));
					}
				else
					{
					iAppFsMonitor->AddLocationL(pathToBeMonitored);		
					}
				CleanupStack::PopAndDestroy(&pathToBeMonitored);
			
				//Adding <driveLetter>:\resource\apps\ path to monitor.
				pathToBeMonitored.CreateL(KAppResourceAppsLocation());
				CleanupClosePushL(pathToBeMonitored);
				pathToBeMonitored.Replace(0,1,drive);			
				iAppFsMonitor->AddLocationL(pathToBeMonitored);
				CleanupStack::PopAndDestroy(&pathToBeMonitored);
				}
			maskBit = maskBit << 1;
			}	
		}
	else
		{
		iAppFsMonitor=CApaFsMonitor::NewL(iFs, KAppRegistrationFileImportLocation, TCallBack(&AppFsNotifyCallBack, this));
		iAppFsMonitor->AddLocationL(KAppResourceAppsLocation);
		}	
	}
Пример #21
0
EXPORT_C TInt TRPSOwnNumbers::RetrieveOwnNumbersL(RMobilePhone& aPhone)
	{
	
	RDEBUGPRINTLOGGER1(_L("RPS: TRPSOwnNumbers::RetrieveOwnNumbersL"));
	
	RMobileONStore ownNumberStore;
	User::LeaveIfError(ownNumberStore.Open(aPhone));
	CleanupClosePushL(ownNumberStore);
	
	// Get Own Number Information
	RMobileONStore::TMobileONStoreInfoV1 ownNumberInfo;
	RMobileONStore::TMobileONStoreInfoV1Pckg ownNumberInfoPckg(ownNumberInfo);

	TRequestStatus status;
	ownNumberStore.GetInfo(status, ownNumberInfoPckg);
	User::WaitForRequest(status);
	User::LeaveIfError(status.Int());

	//
	// Read entire Own Number store entries if supported
	//
	TInt errorReadingWhole = KErrNone;
	TInt errorsExtractANumber(0);

	if(ownNumberInfo.iCaps & (TUint32)RMobilePhoneStore::KCapsWholeStore)
		{
		// Reads phone's entire ON list
		CMobilePhoneONList* onList = NULL;
		
		// Assumes we have a scheduler to work with.
		CActiveScheduler* sched = CActiveScheduler::Current();
		
		CActiveONRetrieverRps* retriever = new(ELeave)CActiveONRetrieverRps(ownNumberStore, onList, errorReadingWhole, sched);
		CleanupStack::PushL(retriever);
		retriever->StartL();
		sched->Start();

		if(!errorReadingWhole)
			{
			// Verify that the name and number are OK.
			TInt numOfEntry = onList->Enumerate();
			for(TInt x = 0; x < numOfEntry; ++x)
				{		
				
				if(ExtractANumber(onList->GetEntryL(x)) != KErrNone)
					++errorsExtractANumber;
				}
			}
		delete onList;

		CleanupStack::PopAndDestroy();

		}

	TInt lenVoiceNum(iOwnVoiceNumber.Length());
	TInt lenFaxNum(iOwnFaxNumber.Length());
	TInt lenDataNum(iOwnDataNumber.Length());

	if(!(lenVoiceNum && lenFaxNum && lenDataNum))
		{
		// Try reading ON store one entry at a time
		for (TInt i = 1; i <= ownNumberInfo.iTotalEntries; i++)
			{
			RMobileONStore::TMobileONEntryV1 ownNumberEntry;
		
			ownNumberEntry.iIndex = i;
			RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg(ownNumberEntry);

			ownNumberStore.Read(status, ownNumberEntryPckg);
			User::WaitForRequest(status);
			
			ExtractANumber(ownNumberEntry);
			}

			// As the last resort, 
			// if the voice number has not been found, assume it is under the Unspecified service tag
			if(iOwnVoiceNumber.Length() == 0)
				{
				RMobileONStore::TMobileONEntryV1 ownNumberEntry;
				ownNumberEntry.iIndex = 1;
				RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg(ownNumberEntry);
				ownNumberStore.Read(status, ownNumberEntryPckg);
				User::WaitForRequest(status);
			
				if (ownNumberEntry.iService == RMobilePhone::EServiceUnspecified)
					{
					TBuf<1> prependstr;
					prependstr.Zero();
					if(ownNumberEntry.iNumber.iTypeOfNumber == RMobilePhone::EInternationalNumber || 
					   ownNumberEntry.iNumber.iTelNumber.Left(2) == KUKCountryCode)
						{
						prependstr = KPlus;
						}
					iOwnVoiceNumber = prependstr;
					iOwnVoiceNumber += ownNumberEntry.iNumber.iTelNumber;
					}
				}
		}

	CleanupStack::PopAndDestroy(); //ownNumberStore
	
	//often fax and data numbers are blank on the SIM so if that is the case then set them to be same as voice
	//Hopefully attempting to dial a data/fax call using the voice number should still work
	if(iOwnDataNumber.Length() == 0)
		iOwnDataNumber = iOwnVoiceNumber;
	
	if(iOwnFaxNumber.Length() == 0)
		iOwnFaxNumber = iOwnVoiceNumber;
	
	RDEBUGPRINTLOGGER2(_L("RPS: iOwnVoiceNumber=%S"), &iOwnVoiceNumber);
	RDEBUGPRINTLOGGER2(_L("RPS: iOwnDataNumber=%S"), &iOwnDataNumber);
	RDEBUGPRINTLOGGER2(_L("RPS: iOwnFaxNumber=%S"), &iOwnFaxNumber);

	return KErrNone;	
	}
Пример #22
0
// ---------------------------------------------------------
// CFepSetupContainer::InstallFepL
// ---------------------------------------------------------
//
void CFepSetupContainer::InstallFepL()
	{
	TBuf<KFormatBufSize> formatingBuf;

    TInt index( 0 );
    CAknListQueryDialog* dlg = new(ELeave) CAknListQueryDialog( &index );
    dlg->PrepareLC( R_FEPSETUP_LIST_QUERY );
    dlg->SetItemTextArray( iNamesOfAvailableFeps );
    dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Execute the dialog
	TInt answer = dlg->RunLD();

    if( answer == EAknSoftkeyOk )
		{
#ifndef __SERIES60_3X__ // Series60 1.x/2.x API
		iEikonEnv->InfoMsg( TParsePtrC( iFileNamesOfAvailableFeps->MdcaPoint( index )).Name());

		// The code below is to check whether the selected Fep is already installed.
		HBufC* fepToInstall = iFileNamesOfAvailableFeps->MdcaPoint( index ).AllocL();
		CleanupStack::PushL( fepToInstall );
		TPtr fepToInstallPtr( fepToInstall->Des() );
        fepToInstallPtr.LowerCase(); // remove case-sensitivity
		TPtrC fepToInstallPtrC( TParsePtrC( fepToInstallPtr ).Name()); // file name parsing

		HBufC* currentFep = iCoeEnv->NameOfInstalledFepL();
		
		CleanupStack::PushL( currentFep );
		TPtr currentFepPtr( currentFep->Des() );
        currentFepPtr.LowerCase(); // remove case-sensitivity
		TPtrC currentFepPtrC( TParsePtrC( currentFepPtr ).Name()); // file name parsing

		if( fepToInstallPtrC.Compare( currentFepPtrC ) == 0) // Already installed?
			{
			formatingBuf.Format( KFepAlreadyInstalled, &fepToInstallPtrC );
			}
		else
			{
			// Loads the specified FEP DLL into all running applications.
			// The current loaded FEP, if any, will be unloaded.
			iCoeEnv->InstallFepL( iFileNamesOfAvailableFeps->MdcaPoint( index ));

			formatingBuf.Format( KFepInstalled, &fepToInstallPtrC );
			}

		CAknConfirmationNote* confirmationDialog = new(ELeave)CAknConfirmationNote();
		confirmationDialog->ExecuteLD( formatingBuf );

		CleanupStack::PopAndDestroy( 2 ); // currentFep, fepToInstall;

#else // Series60 3.x API

		TPtrC fepToInstallPtr( TParsePtrC( iNamesOfAvailableFeps->MdcaPoint( index )).Name()); // file name parsing
		iEikonEnv->InfoMsg( fepToInstallPtr );

		// The code below is to check whether the selected Fep is already installed.
		TUid fepToInstallUid = iFepUids[index];
		TUid currentFepUid = iEikonEnv->FepUid();
		
		if( currentFepUid == fepToInstallUid )
			{
			formatingBuf.Format( KFepAlreadyInstalled, &fepToInstallPtr );
			}
		else
			{
			// Loads the specified FEP DLL into all running applications.
			// The current loaded FEP, if any, will be unloaded.
			iCoeEnv->InstallFepL( fepToInstallUid );

			formatingBuf.Format( KFepInstalled, &fepToInstallPtr );
			}
		CAknConfirmationNote* confirmationDialog = new(ELeave)CAknConfirmationNote();
		confirmationDialog->ExecuteLD( formatingBuf );			
#endif		
		}
	else
		{
		iEikonEnv->InfoMsg( KNoFep );
		}
	}
Пример #23
0
TVerdict RGlobalEffectMainTest::DoTestStepL()
	{
	INFO_PRINTF1(_L("Check basic API calls on TestPlugin"));
	TVerdict result = EPass;
	
	__MM_HEAP_MARK;

	CTestGlobalEffect* plugin = NULL;
	
	TRAPD(error, plugin = CTestGlobalEffect::NewL(NULL));
	
	if (error!=KErrNone)
		{
		INFO_PRINTF2(_L("CreateImplementationL() failed - %d"), error);
		return EFail;
		}
		
	CleanupStack::PushL(plugin);
	
	{
	// check Capability
	TUint value = plugin->Capability(EFalse);
	if (value!=0)
		{
		INFO_PRINTF2(_L("Capability(EFalse): expected 0 got - %d"), value);
		result = EFail;
		}
	value = plugin->Capability(ETrue);
	if (value!=0xffff)
		{
		INFO_PRINTF2(_L("Capability(ETrue): expected -1 got - %d"), value);
		result = EFail;
		}
	}
	
	// check settings by des, uid or value
	HBufC8* tempDes = NULL;
	TUid tempUid;
	TInt tempInt;
	TPckg<TInt> tempPackage (tempInt);
	{
	// initially (stage 1) nothing set, so SettingsByUidL() and ExtractValuesL()
	// should leave KErrNotSupported, and SettingsByDesL() should return "1234"
	
	TRAP(error, tempDes = plugin->SettingsByDesL());
	if (error==KErrNone)
		{
		CleanupStack::PushL(tempDes);
		if (*tempDes!=_L8("1234"))
			{
			HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length());
			tempDes16->Des().Copy(*tempDes);
			INFO_PRINTF2(_L("Stage1: SettingsByDesL() expected \"1234\" got \"%S\""), tempDes16);
			result = EFail;
			CleanupStack::PopAndDestroy(tempDes16);
			}
		CleanupStack::PopAndDestroy(tempDes);	
		tempDes = NULL;	
		}
	else
		{
		INFO_PRINTF2(_L("Stage1: SettingsByDesL() returned %d"), error);
		result = EFail;
		}
	
	TRAP(error, tempUid = plugin->SettingsByUidL());	
	if (error!=KErrNotSupported)
		{
		INFO_PRINTF3(_L("Stage1: SettingsByUidL() expected KErrNotSupported got %d(0x%x)"), error, tempUid.iUid);
		result = EFail;
		}
		
	TRAP(error, plugin->ExtractValuesL(tempPackage));
	if (error!=KErrNotSupported)
		{
		INFO_PRINTF3(_L("Stage1: ExtractValuesL() expected KErrNotSupported got %d(%d)"), error, tempInt);
		result = EFail;
		}
	
	}
		
	{
	// at stage 2, we set a value by UID, so now SettingsByUid returns something sensible
	TUid sampleUid = {0x1234567}; // any silly value will do
	plugin->SetSettingsByUidL(sampleUid);
	
	TRAP(error, tempDes = plugin->SettingsByDesL());
	if (error==KErrNone)
		{
		CleanupStack::PushL(tempDes);
		if (*tempDes!=_L8("1234"))
			{
			HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length());
			tempDes16->Des().Copy(*tempDes);
			INFO_PRINTF2(_L("Stage2: SettingsByDesL() expected \"1234\" got \"%S\""), tempDes16);
			result = EFail;
			CleanupStack::PopAndDestroy(tempDes16);
			}
		CleanupStack::PopAndDestroy(tempDes);	
		tempDes = NULL;	
		}
	else
		{
		INFO_PRINTF2(_L("Stage2: SettingsByDesL() returned %d"), error);
		result = EFail;
		}
	
	TRAP(error, tempUid = plugin->SettingsByUidL());	
	if (error!=KErrNone)
		{
		INFO_PRINTF3(_L("Stage2: SettingsByUidL() expected KErrNone got %d(0x%x)"), error, tempUid.iUid);
		result = EFail;
		}
	else if (tempUid != sampleUid)
		{
		INFO_PRINTF3(_L("Stage2: SettingsByUidL() expected return of 0x%x got 0x%x"), sampleUid.iUid, tempUid.iUid);		
		}
		
	TRAP(error, plugin->ExtractValuesL(tempPackage));
	if (error!=KErrNotSupported)
		{
		INFO_PRINTF3(_L("Stage2: ExtractValuesL() expected KErrNotSupported got %d(%d)"), error, tempInt);
		result = EFail;
		}
	
	}
		
	{
	// at stage 3, we set a value by des, so again only SettingsByDesL() gives valid results
	_LIT8(KSampleDes, "89a");
	plugin->SetSettingsByDesL(KSampleDes);
	
	TRAP(error, tempDes = plugin->SettingsByDesL());
	if (error==KErrNone)
		{
		CleanupStack::PushL(tempDes);
		if (*tempDes!=KSampleDes)
			{
			HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length());
			tempDes16->Des().Copy(*tempDes);
			INFO_PRINTF2(_L("Stage3: SettingsByDesL() expected \"89a\" got \"%S\""), tempDes16);
			result = EFail;
			CleanupStack::PopAndDestroy(tempDes16);
			}
		CleanupStack::PopAndDestroy(tempDes);	
		tempDes = NULL;	
		}
	else
		{
		INFO_PRINTF2(_L("Stage3: SettingsByDesL() returned %d"), error);
		result = EFail;
		}
	
	TRAP(error, tempUid = plugin->SettingsByUidL());	
	if (error!=KErrNotSupported)
		{
		INFO_PRINTF3(_L("Stage3: SettingsByUidL() expected KErrNotSupported got %d(0x%x)"), error, tempUid.iUid);
		result = EFail;
		}
		
	TRAP(error, plugin->ExtractValuesL(tempPackage));
	if (error!=KErrNotSupported)
		{
		INFO_PRINTF3(_L("Stage3: ExtractValuesL() expected KErrNotSupported got %d(%d)"), error, tempInt);
		result = EFail;
		}
	}
		
	{
	// at stage 4, we set a value by package buffer, so only that way returns valid value
	const TInt sampleInt = 10;
	TPckgC<TInt> sampleBuffer (sampleInt);
	plugin->SetByValuesL(sampleBuffer);
	
	TRAP(error, tempDes = plugin->SettingsByDesL());
	if (error==KErrNone)
		{
		CleanupStack::PushL(tempDes);
		HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length());
		tempDes16->Des().Copy(*tempDes);
		INFO_PRINTF2(_L("Stage4: SettingsByDesL() expected KErrNotSupported got \"%S\""), tempDes16);
		result = EFail;
		CleanupStack::PopAndDestroy(2, tempDes);	
		tempDes = NULL;	
		}
	else if (error!=KErrNotSupported)
		{
		INFO_PRINTF2(_L("Stage4: SettingsByDesL() expected KErrNotSupported returned %d"), error);
		result = EFail;
		}
	
	TRAP(error, tempUid = plugin->SettingsByUidL());	
	if (error!=KErrNotSupported)
		{
		INFO_PRINTF3(_L("Stage4: SettingsByUidL() expected KErrNotSupported got %d(0x%x)"), error, tempUid.iUid);
		result = EFail;
		}
		
	TRAP(error, plugin->ExtractValuesL(tempPackage));
	if (error!=KErrNone)
		{
		INFO_PRINTF3(_L("Stage4: ExtractValuesL() expected KErrNone got %d(%d)"), error, tempInt);
		result = EFail;
		}
	else if (tempInt!=sampleInt)
		{
		INFO_PRINTF3(_L("Stage4: ExtractValuesL() expected %d got %d"), sampleInt, tempInt);
		result = EFail;
		}
	}
	
	{
	// Check for Enabled() and IsActive() - should be false to start. poke value and show have
	// changed. Have to use custom command for SetActive() since not really the way to drive
	// - this should relate to the underlying implementation
	TBool enabled = plugin->IsEnabled();
	TBool active = plugin->IsActive();
	if (enabled!=EFalse || active!=EFalse)
		{
		INFO_PRINTF3(_L("Check1: active(%d) and enabled(%d) should have been false"), active, enabled);
		result = EFail;
		}
	plugin->SetEnabledL(ETrue);
	plugin->SetActive(ETrue);
	enabled = plugin->IsEnabled();
	active = plugin->IsActive();
	if (enabled==EFalse || active==EFalse)
		{
		INFO_PRINTF3(_L("Check2: active(%d) and enabled(%d) should have been true"), active, enabled);
		result = EFail;
		}
	}
	
	{
	// check preset - for test this ties up with the test plugin
	const TInt KPresetsCount = 3;
	MMmfGlobalAudioPresetList* list = plugin->KnownPresetsL();

	// reproduce what the plugin will do and check
	if (list->MdcaCount()!=KPresetsCount)
		{
		INFO_PRINTF3(_L("Expected %d presets, got %d"), KPresetsCount, list->MdcaCount());
		result = EFail;
		}
	else
		{
		for (TInt index=0; index<KPresetsCount; index++)
			{
			TBuf<10> name;
			name.Num(index);
			TUid tempUid={index};
			
			TUid foundUid = list->GAPUidPoint(index);
			const TPtrC foundName = list->MdcaPoint(index);
			
			if (foundUid!=tempUid)
				{
				INFO_PRINTF4(_L("Index %d, expected %x found %x"), index, tempUid.iUid, foundUid.iUid);
				result = EFail;
				}
			if (foundName != name)
				{
				INFO_PRINTF4(_L("Index %d, expected %S found %S"), index, &name, &foundName);
				result = EFail;
				}
			}
		
		}
	}

	CleanupStack::PopAndDestroy(plugin);
	
	__MM_HEAP_MARKEND;
	
	return result;
	}
Пример #24
0
// ---------------------------------------------------------
// CFepSetupContainer::UnInstallFepL
// ---------------------------------------------------------
//
void CFepSetupContainer::UnInstallFepL()
	{
	TBuf<KFormatBufSize> formatingBuf;

#ifndef __SERIES60_3X__ // Series60 1.x/2.x API
	HBufC* currentFep = iCoeEnv->NameOfInstalledFepL();
	CleanupStack::PushL( currentFep );
	
	TPtr currentFepPtr( currentFep->Des() );
    currentFepPtr.LowerCase(); // remove case-sensitivity
	TPtrC currentFepPtrC( TParsePtrC( currentFepPtr ).Name()); // file name parsing

	if( ConeUtils::FileExists( KAknFepFileName )) // 2ndfp2 platform and newer use aknfep.fep
		{
		if( currentFepPtrC.Compare( TParsePtrC( KAknFepFileName ).Name() ) != 0 ) // Already installed?
			{
			iCoeEnv->InstallFepL( KAknFepFileName ); // Install the default Fep
			formatingBuf.Format( KFepUninstalled, &currentFepPtrC );
			}
		else
			{
			formatingBuf.Format( KFepAlreadyInstalled, &currentFepPtrC );
			}
		}
	else // older platforms use T9fep.fep
		{
		if( currentFepPtrC.Compare( TParsePtrC( KT9FepFileName ).Name() ) != 0 ) // Already installed?
			{
			iCoeEnv->InstallFepL( KT9FepFileName ); // Install the default Fep
			formatingBuf.Format( KFepUninstalled, &currentFepPtrC );
			}
		else
			{
			formatingBuf.Format( KFepAlreadyInstalled, &currentFepPtrC );
			}
		}

	CAknConfirmationNote* dialog = new(ELeave)CAknConfirmationNote();
	dialog->ExecuteLD( formatingBuf );

	CleanupStack::PopAndDestroy(); // currentFep
	
#else // Series60 3.x API

	TUid currentFepUid = iEikonEnv->FepUid();
	TInt defaultIndex = iFepUids.Find( KAknFepUid );
	TPtrC defaultFepPtr( TParsePtrC( iNamesOfAvailableFeps->MdcaPoint( defaultIndex )).Name()); // file name parsing
	if( currentFepUid == KAknFepUid )  // Already installed?
		{
		formatingBuf.Format( KFepAlreadyInstalled, &defaultFepPtr );
		}
	else
		{
		iCoeEnv->InstallFepL( KAknFepUid );  // Install the default Fep

		formatingBuf.Format( KFepInstalled, &defaultFepPtr );
		}
	CAknConfirmationNote* confirmationDialog = new(ELeave)CAknConfirmationNote();
	confirmationDialog->ExecuteLD( formatingBuf );			
#endif	
	}
Пример #25
0
/*
-------------------------------------------------------------------------------

    Class: TStifUtil

    Method: CorrectFilePath

    Description: Checks if file path contains drive letter. If not file is serched
                 on all drives and first hit is added to file name.

    Parameters: TDes& aFilePath: in/out: file path to correct

    Return Values: None

    Errors/Exceptions: Leaves if some of called leaving methods leaves

-------------------------------------------------------------------------------
*/
EXPORT_C void TStifUtil::CorrectFilePathL( TDes& aFilePath )
	{
	_LIT( KDriveSelector, ":\\" );
	_LIT( KDriveSelectorFormat_1, "%c:" );                                                                  
	_LIT( KDriveSelectorFormat_2, "%c:\\" );                                                                
	TChar KDriveZ = EDriveZ;//'Z';                                                                          
	                                                                                                              
	_LIT( KBackslash, "\\" );                                                                              
	                                                                                                                
	TInt length = aFilePath.Length();                                                                      
	                                                                                                                
	if (length == 0 )                                                                                     
	   {                                                                                                  
	   return;                                                                                            
	   }                                                                                                  
	if (length > 2 )                                                                                      
	   {                                                                                                  
	   // Check if file path contains drive selector                                                      
	   if ( aFilePath.Mid( 1, 2 ) == KDriveSelector )                                                     
	       {                                                                                               
	       // File path contains selector letter so we have nothing to do here                             
	       return;                                                                                         
	       }                                                                                               
	   }                                                                                                  
	                                                                                                                
	// Check if file path contains backslash at the begining and                                          
	// select proper drive selector format according to this information                                  
	TInt driveSelectorFormat = 2;                                                                         
	if ( aFilePath.Mid( 0, 1 ) == KBackslash )                                                            
	   {                                                                                               
	   driveSelectorFormat = 1;                                                                        
	   }                                                                                               
	                                                                                                                
	RFs rfs;                                                                                              
	if ( rfs.Connect() != KErrNone )                                                                      
	   {                                                                                                  
	   return;                                                                                            
	   }                                                                                                  
	                                                                                                                
	// Get available drives list, revers it order and move z drive at                                     
	// the end of the list.  
	TDriveList drivesList; 
	rfs.DriveList(drivesList); 

	// Set drive variable to last drive (except for Z, which will be checked at the end)
	char drive = 'Y' ;

	// Loop through all the drives in following order: YX..CBAZ
	while(drive >= 'A' && drive <= 'Z')
	     {
	     // Do further action only if drive exists
	     TInt driveint;
	     rfs.CharToDrive(drive, driveint);
	     if(drivesList[driveint])
	          {
	          //further checking (drive selector and file existence)
	          
	          // Prepare drive selector                                                                         
	          TBuf<3> driveSelector;                                                                            
	          if ( driveSelectorFormat == 1 )                                                                   
	              {                                                                                           
	              driveSelector.Format( KDriveSelectorFormat_1, drive );                                    
	              }                                                                                           
	          else if ( driveSelectorFormat == 2 )                                                              
	              {                                                                                           
	              driveSelector.Format( KDriveSelectorFormat_2, drive );                                    
	              }                                                                                           
	                                                                                                                
	          aFilePath.Insert( 0, driveSelector );                                                             
	                                                                                                                
	          TEntry entry;                                                                                     
	          if ( rfs.Entry(aFilePath, entry) == KErrNone )                                                    
	              {                                                                                         
	              rfs.Close();                                                                                
	              return;                                                                                     
	              }                                                                                           
	                                                                                                                
	          // File does not exists on selected drive. Restoring orginal file path                            
	          aFilePath.Delete( 0, driveSelector.Length() );    	         
	          }//if(drivesList[driveint])       
	            
	   // Select next drive
	   if(drive == 'Z')
	       break; // the last driver
	   else if(drive ==  'A' )
	       drive = 'Z'; //after checking A check Z
	   else
	       drive =  (TChar)(TInt(drive)-1) ; //after checking Y check X and so on in reverse alphabetical order
	   } //while 
	rfs.Close(); 
	}
// ---------------------------------------------------------
// CCertManUIContainerTrust::UpdateTrustListboxItemL(CCrCertEntry& aEntry,
//                                              TInt aCurrentTruster)
// Updates the Trust Settings Listbox item value
// Can be called only for those certificates that are
// located in ECrCertLocationCertMan !!!
// Cannot be called for certificates located in ECrCertLocationWIMCard,
//                        ECrCertLocationWIMURL,
//                        ECrCertLocationPhoneMemory
//                        ECrCertLocationPhoneMemoryURL
// Certificate formats ECrX968Certificate ECrCertificateURL
// are not visible in the Trust View
// ---------------------------------------------------------
//
void CCertManUIContainerTrust::UpdateTrustListboxItemL(CCTCertInfo& aEntry,
                                                       TInt aCurrentTruster)
    {
    CERTMANUILOGGER_ENTERFN( " CCertManUIContainerTrust::UpdateTrustListboxItemL" );

    MDesCArray* itemList = iListBox->Model()->ItemTextArray();
    CDesCArray* itemArray = STATIC_CAST( CDesCArray*, itemList );
    TCertificateFormat format = aEntry.CertificateFormat();
    TUid id = KCertManUINullId;

    TInt poppableItems = 0;

    TInt index = 0;

    if ( format == EX509Certificate )
        {
        id = iClientUids[ aCurrentTruster ];
        index = aCurrentTruster;
        }

    if ( id != KCertManUINullId )
        {
        TBuf<KMaxLengthTextSettListOneTwo> item;

        if ( id == KCertManUIViewTrustApplicationControllerId )
            {
            item = (*iTrustedClients)[ KTrustSettingsResourceIndexAppCtrl ];
            }
        else if ( id == KCertManUIViewTrustMailAndImageConnId )
            {
            item =
             (*iTrustedClients)[ KTrustSettingsResourceIndexMailAndImageConn ];
            }
        else if ( id == KCertManUIViewTrustJavaInstallingId )
            {
            item =
             (*iTrustedClients)[ KTrustSettingsResourceIndexJavaInstall ];
            }
        else if ( id == KCertManUIViewOCSPCheckInstallingId )
            {
            item =
             (*iTrustedClients)[ KTrustSettingsResourceIndexOCSPCheck ];
            }
        else if ( id == KCertManUIViewTrustVPNId )
            {
            item =
             (*iTrustedClients)[ KTrustSettingsResourceIndexVPN ];
            }
        else
            {
            if ( iApps.Count() > 0 )
                {
                const TName& name = iApps[index].Name();
                TInt fieldLength = name.Length();
                TBuf<KMaxLengthTextSettListOneTwo> item2;
                if ( fieldLength >= KMaxLengthTextSettListOne )
                    {
                    item2 = name.Mid( 0, KMaxLengthTextSettListOne );
                    }
                else
                    {
                    item2 = name;
                    }
                item.Format( KCertManUIFormatDescriptorTrustSettings, &item2 );
                }
            }

        if ( item.Length() )
            {
            if ( CheckCertificateClientTrustL(id, aEntry) )
                {
                item += (*iTrustValues)[ KTrustSettingsResourceIndexValueYes ];
                }
            else
                {
                item += (*iTrustValues)[ KTrustSettingsResourceIndexValueNo ];
                }
            // need to Delete first the old Yes/No entry
            itemArray->Delete( aCurrentTruster );
            itemArray->InsertL( aCurrentTruster, item );
            }
        }

    CleanupStack::PopAndDestroy( poppableItems );

    iListBox->HandleItemAdditionL();

    CERTMANUILOGGER_LEAVEFN( " CCertManUIContainerTrust::UpdateTrustListboxItemL" );
    }
/**
 * Load and initialise an audio file.
 */
TVerdict CTestMmfAclntFileSource::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);
	
	// Create CMdaAudioPlayerUtility Object
	CMdaAudioPlayerUtility* player = NULL;
	player = CMdaAudioPlayerUtility::NewL(*this);
	
	// Create TMMFileSource Object
	TMMFileSource filesource(filename);
	player->OpenFileL(filesource);
	
	// Wait for initialisation callback
	INFO_PRINTF1(_L("Initialise CMdaAudioPlayerUtility"));
	CActiveScheduler::Start();
	
	// Check for expected errors.
	if(iError != KErrNone && (iExpectedError == iError))
		{
		ret = EPass;	// all other tests pass
		delete player;
		User::After(KOneSecond); // wait for deletion to shut down devsound
		ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with expected error %d"),iError );
		return ret;
		}

	// Check for errors (after OPEN).
	if (iError == KErrNone && player != NULL)
		{
		if(iPlay)
			{
			iError = KErrTimedOut;
			player->Play();
			
			// Wait for play complete callback
			INFO_PRINTF1(_L("Play CMdaAudioPlayerUtility"));
			CActiveScheduler::Start();
			
			// Check for Callback errors
			if(iError == KErrNone)
				{
				ret = EPass;
				}
			}
		else
			{
			ret = EPass;
			}
		}
	
	// Clean up activities.
	delete player;
	User::After(KOneSecond); // wait for deletion to shut down devsound

	// Check for errors (final check).
	if(iError != KErrNone)
		{
		ERR_PRINTF2( _L("CMdaAudioPlayerUtility failed with error %d"),iError );
		}
	return	ret;
	}
// ---------------------------------------------------------------------------
// CCertManUIContainerTrust::PopupTrustChangeSettingPageL(
//      TInt aCertificateIndex)
// Finds out which client was focused in Trust Settings view and calls
// ShowTrustChangeSettingPageL This is accessed only by X509S
// certificates, located in CertMan and having one or more clients
// Must be public so that viewTrust can access
// ---------------------------------------------------------------------------
//
void CCertManUIContainerTrust::PopupTrustChangeSettingPageL(
    TInt aCertificateIndex )
    {
    CERTMANUILOGGER_ENTERFN( " CCertManUIContainerTrust::PopupTrustChangeSettingPageL" );

    // Use certificate index from previous view
    CCTCertInfo* entry =
        iKeeper.iCALabelEntries[ aCertificateIndex ]->iCAEntry;

    // if the certificate is read-only, trust settings cannot be changed
    if( !entry->IsDeletable() )
    	{
        CERTMANUILOGGER_LEAVEFN( "- PopupTrustChangeSettingPageL - read-only" );
    	return;
    	}
    
    TUid id = KCertManUINullId;
    TInt poppableItems = 0;

    TBuf<KMaxLengthTextSettListOne> clientName;

    // get position of the focus in the Trust Settings view
    TInt currentPosition = iListBox->CurrentItemIndex();
    id = iClientUids[ currentPosition ];

    if ( id != KCertManUINullId )
        {
        // Native installation
        if ( id == KCertManUIViewTrustApplicationControllerId )
            {
            clientName =
                    (*iTrustedClients)[ KTrustSettingsResourceIndexAppCtrl ];
            }
        // TLS
        else if ( id == KCertManUIViewTrustMailAndImageConnId )
            {
            clientName =
                  (*iTrustedClients)[
                  KTrustSettingsResourceIndexMailAndImageConn ];
            }
        // Midlet installation
        else if ( id == KCertManUIViewTrustJavaInstallingId )
            {
            clientName =
                  (*iTrustedClients)[
                  KTrustSettingsResourceIndexJavaInstall ];
            }
        // OCSP
        else if ( id == KCertManUIViewOCSPCheckInstallingId )
            {
            clientName =
                  (*iTrustedClients)[
                  KTrustSettingsResourceIndexOCSPCheck ];
            }
        // VPN
        else if ( id == KCertManUIViewTrustVPNId )
            {
            clientName =
                  (*iTrustedClients)[
                  KTrustSettingsResourceIndexVPN ];
            }
        else
            {
            if ( iApps.Count() > 0 )
                {
                const TName& name = iApps[currentPosition].Name();
                TInt fieldLength = name.Length();
                if ( fieldLength >= KMaxLengthTextSettListOne )
                    {
                    clientName = name.Mid(0, KMaxLengthTextSettListOne);
                    }
                else
                    {
                    clientName = name;
                    }
                }
            }
        }

    if ( id != KCertManUINullId )
        {
        clientName.TrimLeft();
        clientName.TrimRight();
        ShowTrustChangeSettingPageL( id, clientName, *entry );
        }

    CleanupStack::PopAndDestroy( poppableItems );  // clients

    CERTMANUILOGGER_LEAVEFN( " CCertManUIContainerTrust::PopupTrustChangeSettingPageL" );
    }
Пример #29
0
void CWordStyleGallery::FillBufferL(const CParaFormatLayer& aParaFormatLayer)
	{
	CEikGlobalTextEditor* edwin=(CEikGlobalTextEditor*)Control(EWordCidStyleInfo);
	TCharFormat charFormat;
	TCharFormatMask charMask;
	CParaFormat* paraFormat=CParaFormat::NewLC();
	TParaFormatMask paraMask;
	//
	//
	iCurrentDescription=HBufC::NewL(KDescriptionGranularity);
	TPtr buf=iCurrentDescription->Des();
	TBool isNormalStyle=(aParaFormatLayer.Type()==KNormalParagraphStyleUid);
	if (!isNormalStyle)
		{
		const CParagraphStyle* flayer=REINTERPRET_CAST(const CParagraphStyle*,aParaFormatLayer.SenseBase());
		TUid type=flayer->Type();
		if (type==KNormalParagraphStyleUid)
			buf.Append(iNormalName);
		else
			buf.Append(flayer->iName);
		buf.Append('+');
		}
	//
	if (isNormalStyle)
		iData.iText.GlobalCharFormatLayer()->Sense(charFormat,charMask);
	else
		REINTERPRET_CAST(const CParagraphStyle&,aParaFormatLayer).CharFormatLayer()->Sense(charFormat,charMask);
	aParaFormatLayer.SenseL(paraFormat,paraMask);
	//
	if (!charMask.IsNull())
		{
		if (charMask.AttribIsSet(EAttFontTypeface))
			DoAppendDescriptionL(charFormat.iFontSpec.iTypeface.iName);
		if (charMask.AttribIsSet(EAttFontHeight))
			{
			TInt height=charFormat.iFontSpec.iHeight;
			height=(height+10)/20;
			TBuf<20> num;
			num.Num(height);
			TBuf<10> unit;
			iCoeEnv->ReadResource(unit,R_WORD_FONT_UNITS);
			num.Append(unit);
			DoAppendDescriptionL(num);
			}
		if (charMask.AttribIsSet(EAttFontPosture))
			{
			if (charFormat.iFontSpec.iFontStyle.Posture()==EPostureItalic)
				DoAppendDescriptionL((*iStyleDescriptor)[EDesItalic]);
			}
		if (charMask.AttribIsSet(EAttFontStrokeWeight))
			{
			if (charFormat.iFontSpec.iFontStyle.StrokeWeight()==EStrokeWeightBold)
				DoAppendDescriptionL((*iStyleDescriptor)[EDesBold]);
			}
		if (charMask.AttribIsSet(EAttFontPrintPos))
			{
			TFontPrintPosition pos=charFormat.iFontSpec.iFontStyle.PrintPosition();
			switch(pos)
				{
			case EPrintPosSuperscript:
				DoAppendDescriptionL((*iStyleDescriptor)[EDesSuperscript]);
				break;
			case EPrintPosSubscript:
				DoAppendDescriptionL((*iStyleDescriptor)[EDesSubscript]);
				break;
			default:
				break;
				}
			}
		if (charMask.AttribIsSet(EAttFontUnderline))
			{
			if (charFormat.iFontPresentation.iUnderline==EUnderlineOn)
				DoAppendDescriptionL((*iStyleDescriptor)[EDesUnderline]);
			}
		if (charMask.AttribIsSet(EAttFontStrikethrough))
			{
			if (charFormat.iFontPresentation.iStrikethrough==EStrikethroughOn)
				DoAppendDescriptionL((*iStyleDescriptor)[EDesStrikethrough]);
			}
		}
	if (!paraMask.IsNull())
		{
		AppendDescriptionL(EAttLeftMargin,paraMask);
		AppendDescriptionL(EAttRightMargin,paraMask);
		AppendDescriptionL(EAttIndent,paraMask);
		if (paraMask.AttribIsSet(EAttAlignment))
			DoAppendDescriptionL((*iStyleDescriptor)[EDesLeftAlign+paraFormat->iHorizontalAlignment]);
		AppendDescriptionL(EAttLineSpacing,paraMask);
		AppendDescriptionL(EAttSpaceBefore,paraMask);
		AppendDescriptionL(EAttSpaceAfter,paraMask);
		AppendDescriptionL(EAttKeepTogether,paraMask);
		AppendDescriptionL(EAttKeepWithNext,paraMask);
		AppendDescriptionL(EAttStartNewPage,paraMask);
		AppendDescriptionL(EAttWidowOrphan,paraMask);
		AppendDescriptionL(EAttBorderMargin,paraMask);
		AppendDescriptionL(EAttTopBorder,*paraFormat,paraMask);
		AppendDescriptionL(EAttBottomBorder,*paraFormat,paraMask);
		AppendDescriptionL(EAttLeftBorder,*paraFormat,paraMask);
		AppendDescriptionL(EAttRightBorder,*paraFormat,paraMask);
		AppendDescriptionL(EAttBullet,paraMask);
		AppendDescriptionL(EAttTabStop,*paraFormat,paraMask);
		}
	CleanupStack::PopAndDestroy();  // paraFormat
	edwin->SetTextL(iCurrentDescription);
	delete iCurrentDescription;
	iCurrentDescription=NULL;
	DrawEdwinL();
	}
Пример #30
0
LOCAL_C void privateSIDRFstest()
//
//
//
	{
//private/UID
	theprivatepath[0]=(TText)gDriveToTest;	
	test.Printf(_L("the Private Path = %S"),&theprivatepath);

	mkdirname.Zero();
	mkdirname.Append(theprivatepath);
	mkdirname.Append(KMkDirSub);
	r=TheFs.MkDirAll(mkdirname);	
	test_KErrNone(r);

	r=TheFs.RmDir(mkdirname);	
	test_KErrNone(r);

	r=TheFs.SetSubst(theprivatepath,EDriveS);	
	test_KErrNone(r);

	r=TheFs.RealName(_L("S:\\File.XXX"),realName);
	test_KErrNone(r);

	r=TheFs.SetSubst(_L(""),EDriveS);	
	test_KErrNone(r);
	
	r=TheFs.SetSessionPath(theprivatepath);
	test_KErrNone(r);

	TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath);
	test(aStat3==KRequestPending);

		pritestfile=theprivatepath;
	pritestfile[0]=(TText)('A' + gTheDriveNum);
	pritestfile1=pritestfile;
	pritestfile.Append(KFilePri2);
	pritestfile1.Append(KFilePri3);
	
	oldName=KOldFile;
	oldName[0]=(TText)gDriveToTest;

	r=TheFs.GetShortName(pritestfile, shortfilename);
	test(r == KErrNone || KErrPathNotFound);
//	test_Value(r, r == KErrNone || r == KErrPathNotFound);

	r=TheFs.GetLongName(pritestfile1, longfilename);
	test(r == KErrNone || KErrPathNotFound);
//	test_Value(r, r == KErrNone || r == KErrPathNotFound);

	r=file1.Create(TheFs,oldName,EFileWrite);
	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
	file1.Close();

	r=TheFs.Replace(oldName,pritestfile);
	test_KErrNone(r);
	
	r=TheFs.Rename(pritestfile,pritestfile1);
	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
	
	r=TheFs.Entry(pritestfile1,entry);
	test_KErrNone(r);

	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
	test_KErrNone(r);

	r=TheFs.Delete(pritestfile1);
	test_KErrNone(r);
	}