TVerdict CTestStepSDevSoundClientThreadNoCap::DoTestStepL( void ) { INFO_PRINTF1( _L("CTestStepSDevSoundClientThreadNoCap : DevSoundMP")); iVerdict = EFail; iServerMonitor = CServerMonitor::NewL(this); RTestServ server; User::LeaveIfError(server.Connect(_L("SDSCapTestServer"))); CleanupClosePushL(server); RTestSession session2; User::LeaveIfError(session2.Open(server,_L("SecDevSndTS0036"))); CleanupClosePushL(session2); TRequestStatus status2 = KRequestPending; session2.StartProcessing(status2); User::WaitForRequest(status2); TPckgBuf<TThreadId> serverTid; session2.EndProcessingAndReturnResult(serverTid); iServerTid = serverTid(); RTestServ mmddServer; User::LeaveIfError(mmddServer.Connect(_L("SDSMMDDTestServer"))); CleanupClosePushL(mmddServer); RTestSession session1; User::LeaveIfError(session1.Open(mmddServer,_L("SecDevSndTS0036"))); CleanupClosePushL(session1); TInt err = DoPlaySimpleTone(); if (err == KErrNone) { if (iAttemptInitialCI) { // assume DoPlaySimpleTone() terminated early prior to InitializeL() iVerdict = EPass; } else { // Start playing simple tone in this thread TRequestStatus status = KRequestPending; session1.StartProcessing(status); iAL->InitialiseActiveListener(); CActiveScheduler::Start(); // Simple tone in this thread finished, wait until the // simple tone playing in the other thread to finish User::WaitForRequest(status); iServerResult = status.Int(); // Verify the results from both threads iVerdict = DoVerifyResult(); TBuf8<256> message; session1.EndProcessingAndReturnResult(message); } } else { iVerdict = EInconclusive; } CleanupStack::PopAndDestroy(4, &server); // session1, mmddServer, session2, server return iVerdict; }
void CTestStepESockSSA::KillC32Start() { // Start by looking for the running configurator and kill it if found. The caller // needs the appropriate capability to do this RDebug::Printf("Finding existing configurator process."); _LIT(KC32StartName, "*"); TInt result; TBool configuratorWasPresent; TInt count = 0; const TInt KMaxKillRetry = 10; do { configuratorWasPresent = EFalse; TFullName fn; TFindProcess fp(KC32StartName); while(fp.Next(fn) == KErrNone) { RProcess proc; result = proc.Open(fn); if(result == KErrNone) { TUidType type = proc.Type(); if(type[2] == TUid::Uid(KUidC32StartProcess) && proc.ExitType() == EExitPending) { // Kill the existing configurator process. RDebug::Print(_L("Opened existing configurator process \"%S\""), &fn); TRequestStatus status; proc.Logon(status); proc.Kill(KErrNone); RDebug::Printf("Killed process."); User::WaitForRequest(status); TExitType exitType = proc.ExitType(); // Create a timer in case some other entity holds an open handle on the // configurator which prevents the kernel from destroying it. We timeout // after one second. TAutoClose<RTimer> timer; if(timer.iObj.CreateLocal() == KErrNone) { // Request destruction notification so we know when it is safe to start // the process again. TRequestStatus destructionStatus; proc.NotifyDestruction(destructionStatus); proc.Close(); enum{ KProcessDestructionTimeout = 1000000 }; TRequestStatus timerStatus; timer.iObj.After(timerStatus, KProcessDestructionTimeout); // Wait for the process to be destroyed or for the timeout. User::WaitForRequest(destructionStatus, timerStatus); if(timerStatus.Int() == KRequestPending) { timer.iObj.Cancel(); User::WaitForRequest(timerStatus); } else { User::CancelMiscNotifier(destructionStatus); User::WaitForRequest(destructionStatus); RDebug::Printf("Existing configurator process has still not been destroyed after %f.0s", KProcessDestructionTimeout / 1000000.0); } } else { proc.Close(); } RDebug::Printf("Process logon completed with %d, exitType %d", status.Int(), exitType); configuratorWasPresent = ETrue; } else { proc.Close(); } } } } while(configuratorWasPresent && ++count < KMaxKillRetry); if (count >= KMaxKillRetry) { RDebug::Printf("KillC32Start - Cannot kill the configurator process, we will try continue and hope all is well"); } // Restart the boot sequence from scratch - the configurator reads this. RProperty::Set(KUidSystemCategory, KUidC32StartPropertyKey.iUid, EReset); }
GLDEF_C TInt E32Main() { __UHEAP_MARK; Test.Title(); TInt r; Test.Start(_L("Load sound PDD")); r=User::LoadPhysicalDevice(KSndPddFileName); if (r==KErrNotFound) { Test.Printf(_L("Shared chunk sound driver not supported - test skipped\r\n")); Test.End(); Test.Close(); __UHEAP_MARKEND; return(KErrNone); } Test(r==KErrNone || r==KErrAlreadyExists); Test.Next(_L("Load sound LDD")); r=User::LoadLogicalDevice(KSndLddFileName); Test(r==KErrNone || r==KErrAlreadyExists); /** @SYMTestCaseID PBASE-T_SOUNDMCHAN-224 @SYMTestCaseDesc Opening the channel - more than one channel @SYMTestPriority Critical @SYMTestActions 1) With the LDD and PDD installed and with all channels closed on the device, open a channel for playback on the device. 2) Without closing the first playback channel, attempt to open a second channel for playback on the same device. @SYMTestExpectedResults 1) KErrNone - Channel opens successfully. 2) Should fail with KErrInUse. @SYMREQ PREQ1073.4 */ __KHEAP_MARK; Test.Next(_L("Open a channel on the play device")); RSoundSc snddev; r=snddev.Open(KSoundScTxUnit0); Test(r==KErrNone); Test.Next(_L("Try opening the same unit a second time.")); RSoundSc snddev2; r=snddev2.Open(KSoundScTxUnit0); Test(r==KErrInUse); Test.Next(_L("Query play formats supported")); TSoundFormatsSupportedV02Buf capsBuf; snddev.Caps(capsBuf); TSoundFormatsSupportedV02& caps=capsBuf(); PrintCaps(caps,Test); Test.Next(_L("Try playing without setting the buffer config")); TRequestStatus pStat; snddev.PlayData(pStat,0,0x2000); // 8K User::WaitForRequest(pStat); Test(pStat.Int()==KErrNotReady); Test.Next(_L("Configure the channel from a 2nd thread")); RThread thread; TRequestStatus tStat; SSecondaryThreadInfo sti; sti.iTestId=ESecThreadConfigPlayback; sti.iThreadId=RThread().Id(); // Get the ID of this thread sti.iDrvHandle=snddev.Handle(); // Pass the channel handle /** @SYMTestCaseID PBASE-T_SOUNDMCHAN-225 @SYMTestCaseDesc Opening the channel - sharing the handle between threads @SYMTestPriority Critical @SYMTestActions 1) With the LDD and PDD installed and with all channels closed on the device, open a channel for playback on the device. Now create a second thread. Resume this thread - passing the handle to the playback channel to it. Wait for the second thread to terminate. 2) In the second thread, duplicate the playback channel handle. 3) In the second thread, using the duplicated handle, issue a request to set the audio configuration. 4) In the second thread, using the duplicated handle, issue a request to set the volume. 5) In the second thread, close the handle and exit the thread. 6) In the first thread, read back the audio configuration. 7) In the first thread, set the buffer configuration, and then issue a request to play audio data. 8) In the first thread, close the channel. @SYMTestExpectedResults 1) KErrNone - Channel opens successfully. 2) KErrNone - Duplication of the handle succeeds. 3) KErrNone - Audio configured successfully. 4) KErrNone - Volume set successfully. 5) No errors occur closing the channel and exiting the thread. 6) The audio configuration should correspond to that set by the second thread. 7) KErrNone - Setting the buffer configuration and issuing a play request. 8) No errors occur closing the channel. @SYMREQ PREQ1073.4 */ r=thread.Create(_L("Thread"),secondaryThread,KDefaultStackSize,KHeapSize,KHeapSize,&sti); // Create secondary thread Test(r==KErrNone); thread.Logon(tStat); thread.Resume(); User::WaitForRequest(tStat); Test(tStat.Int()==KErrNone); // Test.Printf(_L("Thread exit info: Cat:%S, Reason:%x, Type:%d\r\n"),&thread.ExitCategory(),thread.ExitReason(),thread.ExitType()); Test(thread.ExitType()==EExitKill); thread.Close(); User::After(10000); // Wait 10ms Test.Next(_L("Read back the play configuration")); TCurrentSoundFormatV02Buf formatBuf; snddev.AudioFormat(formatBuf); TCurrentSoundFormatV02& format=formatBuf(); PrintConfig(format,Test); Test.Next(_L("Set the buffer configuration")); RChunk chunk; TInt bufSize=BytesPerSecond(formatBuf()); // Large enough to hold 1 second of data. bufSize=ValidBufferSize(bufSize,caps.iRequestMinSize,formatBuf()); // Keep the buffer length valid for driver. TTestSharedChunkBufConfig bufferConfig; bufferConfig.iNumBuffers=1; bufferConfig.iBufferSizeInBytes=bufSize; bufferConfig.iFlags=0; TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig); r=snddev.SetBufferChunkCreate(bufferConfigBuf,chunk); Test(r==KErrNone); snddev.GetBufferConfig(bufferConfigBuf); PrintBufferConf(bufferConfig,Test); Test(bufferConfig.iBufferSizeInBytes==bufSize); Test.Next(_L("Start playing")); r=MakeSineTable(format); Test(r==KErrNone); r=SetToneFrequency(660,format); Test(r==KErrNone); TPtr8 ptr(chunk.Base()+bufferConfig.iBufferOffsetList[0],bufSize); WriteTone(ptr,format); snddev.PlayData(pStat,bufferConfig.iBufferOffsetList[0],bufSize,KSndFlagLastSample); User::WaitForRequest(pStat); Test(tStat.Int()==KErrNone); Test.Next(_L("Close the drivers and the chunk")); chunk.Close(); snddev.Close(); __KHEAP_MARKEND; Test.Next(_L("Unload the drivers")); r=User::FreeLogicalDevice(KDevSoundScName); Test.Printf(_L("Unloading %S.LDD - %d\r\n"),&KDevSoundScName,r); Test(r==KErrNone); TName pddName(KDevSoundScName); _LIT(KPddWildcardExtension,".*"); pddName.Append(KPddWildcardExtension); TFindPhysicalDevice findPD(pddName); TFullName findResult; r=findPD.Next(findResult); while (r==KErrNone) { r=User::FreePhysicalDevice(findResult); Test.Printf(_L("Unloading %S.PDD - %d\r\n"),&findResult,r); Test(r==KErrNone); findPD.Find(pddName); // Reset the find handle now that we have deleted something from the container. r=findPD.Next(findResult); } Test.End(); Test.Close(); Cleanup(); __UHEAP_MARKEND; return(KErrNone); }
/** @SYMTestCaseID BA-CSAT-SUC-SNSUCPC-0001 @SYMPREQ 1780 @SYMComponent telephony_csat @SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpCallPCmd @SYMTestPriority High @SYMTestActions Invokes RSat::NotifySetUpCallPCmd @SYMTestExpectedResults Pass @SYMTestType CT */ void CCSatSetUpCallFU::TestNotifySetUpCallPCmd0001L() { OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); OpenSatL(); TRequestStatus requestStatus; const TUint8 KAddress = 0x91; //10010001 RSat::TSetUpCallV6 setupCallData; TData data; data.iCommandNumber = 1; data.iCommandQualifier = KSetUpCallIfNotCurrentlyBusy; data.iSourceDevice = KSim; data.iDestinationDevice = KNetwork; data.iAddress = KAddress; data.iCommandType = KSetUpCall; _LIT8(KAlphaIdentifier1, "Not busy"); _LIT16(KAlphaIdentifier1_16, "Not busy"); data.iCallNumber.Append(0x10); data.iCallNumber.Append(0x32); data.iCallNumber.Append(0x04); data.iCallNumber.Append(0x21); data.iCallNumber.Append(0x43); data.iCallNumber.Append(0x65); data.iCallNumber.Append(0x1C); data.iCallNumber.Append(0x2C); //------------------------------------------------------------------------- // TEST C: Successful completion request of // RSat::NotifySetUpCallPCmd //------------------------------------------------------------------------- // test C - implemented in 0001b-0001d functions //------------------------------------------------------------------------- // TEST E: Coverage test(s) for RSat::NotifySetUpCallPCmd //------------------------------------------------------------------------- iMockLTSY.NotifyTerminated(requestStatus); PrepareCompleteDataL ( data, KAlphaIdentifier1 ); RSat::TAdditionalInfo additionalInfo; additionalInfo.Append(KNoCause); PrepareTerminalResponseMockDataL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, additionalInfo, RSat::KMeUnableToProcessCmd, KNullDesC8 ); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // to increase CSatNotifySetUpCall::CompleteNotifyL coverage //------------------------------------------------------------------------- PrepareExpectDataL ( data.iCommandType ); RSat::TSetUpCallV6Pckg setpPck(setupCallData); iSat.NotifySetUpCallPCmd(requestStatus, setpPck); RBuf8 bufData; CleanupClosePushL(bufData); TTlv tlv; tlv.Begin(KBerTlvProactiveSimCommandTag); tlv.AddTag(KTlvCommandDetailsTag); // Command details tlv.AddByte(data.iCommandNumber); // Command number tlv.AddByte(data.iCommandType); // Command type tlv.AddByte(data.iCommandQualifier); // Command qualifier tlv.AddTag(KTlvDeviceIdentityTag); // Device identities tlv.AddByte(data.iSourceDevice); // Source device tlv.AddByte(data.iDestinationDevice); // Destination device tlv.AddTag(KTlvAlphaIdentifierTag); tlv.AddTag(KTlvAlphaIdentifierTag); tlv.AddTag(KTlvAddressTag); tlv.AddTag(KTlvSubaddressTag); TPtrC8 tlvDsc = tlv.End(); TDesC8* tlvDscPtr = &tlvDsc; TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr); tlvDscPack.SerialiseL(bufData); iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, KErrNone, bufData, KDelay); PrepareTerminalResponseMockDataL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, KNullDesC16, RSat::KCmdDataNotUnderstood, KNullDesC8 ); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrCorrupt, requestStatus.Int()); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // to increase CSatNotifySetUpCall::CompleteNotifyL coverage // in case of "command qualifier" //------------------------------------------------------------------------- const TUint8 KDefualtCommand = 0x7F; const TUint8 qualifierArray[] = { KHoldOtherCallsWithRedial, KDisconnectOtherCallsWithRedial, KDefualtCommand }; TUint8 sizeArray = sizeof(qualifierArray)/sizeof(qualifierArray[0]); RSat::TSetUpCallRspV2 resp; RSat::TSetUpCallRspV2Pckg respPck(resp); for ( TUint8 i = 0; i < sizeArray; i++ ) { data.iCommandQualifier = qualifierArray[i]; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier1 ); DataCompareL(setupCallData, data.iCommandQualifier, KAlphaIdentifier1_16, RSat::EInternationalNumber, RSat::EIsdnNumberPlan); resp.iInfoType = RSat::KNoAdditionalInfo; resp.iGeneralResult = RSat::KSuccess; CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, resp.iAdditionalInfo, resp.iGeneralResult ); AssertMockLtsyStatusL(); } //------------------------------------------------------------------------- // TEST B: failure on completion of pending request from LTSY->CTSY //------------------------------------------------------------------------- ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier1, KErrGeneral); CleanupStack::PopAndDestroy(2, this); // this, bufData }
/** * This test tests the retrieval of the signal strength. * * @test GT83-SSW-Test01 Test retrieval of the Signal Strength setting. */ enum TVerdict CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::doTestStepL() { // // Make sure watchers are stopped and unloaded before running this test // This forces SIMTSY to be loaded again. // StopWatcher(); SetSimTsyTestNumberL(0); StartWatcher(); CheckSimTsyTestNumberL(0); TInt state; TRequestStatus localStatus; RProperty localProperty; //-- attach and subscribe to KUidNetworkStrength property TESTCHECKL(localProperty.Attach(KUidSystemCategory,KUidNetworkStrength.iUid), KErrNone); localProperty.Subscribe(localStatus); TInt ret = localProperty.Get(state); TESTCHECKL(ret, KErrNone); INFO_PRINTF2(_L("Initial Signal Strength State is %d"), state); INFO_PRINTF1(_L("Commence Wait for Request local status...")); INFO_PRINTF2(_L("Prior to wait cycle, status is %d"), localStatus.Int()); User::WaitForRequest(localStatus); INFO_PRINTF1(_L("Complete Wait for Request local status.")); localProperty.Subscribe(localStatus); ret = localProperty.Get(state); TESTCHECKL(ret, KErrNone); INFO_PRINTF2(_L("Signal Strength State is %d"), state); TESTCHECK(state, ESANetworkStrengthNone); User::WaitForRequest(localStatus); ret = localProperty.Get(state); localProperty.Subscribe(localStatus); TESTCHECKL(ret, KErrNone); INFO_PRINTF2(_L("Signal Strength State is %d"),state); TESTCHECK(state, ESANetworkStrengthLow); User::WaitForRequest(localStatus); ret = localProperty.Get(state); localProperty.Subscribe(localStatus); TESTCHECKL(ret, KErrNone); INFO_PRINTF2(_L("Signal Strength State is %d"),state); TESTCHECK(state, ESANetworkStrengthMedium); User::WaitForRequest(localStatus); ret = localProperty.Get(state); localProperty.Subscribe(localStatus); TESTCHECKL(ret, KErrNone); INFO_PRINTF2(_L("Signal Strength State is %d"),state); TESTCHECK(state, ESANetworkStrengthHigh); User::WaitForRequest(localStatus); ret = localProperty.Get(state); TESTCHECKL(ret, KErrNone); INFO_PRINTF2(_L("Signal Strength State is %d"),state); TESTCHECK(state, ESANetworkStrengthUnknown); return TestStepResult(); } // CTelWatchersIntTestRetrieveSignalStrengthWithPublishSubscribe::doTestStepL
TVerdict CBigSendRecvRtp::doTestStepL() /** * @return - TVerdict code */ { SetTestStepResult(EFail); if(KErrNone == InitSocketsL()) { iIpAddrDest1.SetPort(9000); RBuf8 sendBuf; sendBuf.CreateMax(KBufferSize1); sendBuf.CleanupClosePushL(); RBuf8 recvBuf; recvBuf.CreateMax(KBufferSize1); recvBuf.CleanupClosePushL(); /* Fill the buffer with given character upto its length */ sendBuf.Fill('Q'); TRequestStatus status; /* do a Send of the data */ iRtpSocket.SendTo(sendBuf, iIpAddrDest1, NULL, status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Now do a Receive */ recvBuf.FillZ(); iRtpSocket.RecvFrom(recvBuf,iIpAddrDest1,NULL,status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Obtain a TPtr of the data excluding the RTP header */ TPtr8 sendBufPtr = sendBuf.MidTPtr(KRtpHeaderSize); TPtr8 recvBufPtr = recvBuf.MidTPtr(KRtpHeaderSize); /* Check if the data received is the same as the data sent */ TInt ret = sendBufPtr.Compare(recvBufPtr); if(ret == 0) { /* Increase the buffer size and fill it up with given data */ sendBuf.ReAlloc(KBufferSize2); recvBuf.ReAlloc(KBufferSize2); sendBuf.Fill('Q', KBufferSize2); /* Send the larger data */ iRtpSocket.SendTo(sendBuf, iIpAddrDest1, NULL, status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Now do a Receive */ recvBuf.FillZ(KBufferSize2); iRtpSocket.RecvFrom(recvBuf,iIpAddrDest1,NULL,status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Get pointer to data and compare both of them */ TPtr8 sendBufPtr = sendBuf.MidTPtr(KRtpHeaderSize); TPtr8 recvBufPtr = recvBuf.MidTPtr(KRtpHeaderSize); TInt ret = sendBufPtr.Compare(recvBufPtr); if(ret == 0) { SetTestStepResult(EPass); } } CleanupStack::PopAndDestroy(2); } return TestStepResult(); }
enum TVerdict CEsockTest29_11::easyTestStepL( void ) { TVerdict verdict = EFail; TInt ret; Logger().WriteFormat(_L("Send/ Recv on PDummy3 socket but no avail MBuf Memory, mBuf becomes avail after send")); RSocketServ ss; ret = ss.Connect(); TESTL(KErrNone == ret); CleanupClosePushL(ss); // open dummy prot 3 Logger().WriteFormat(_L("Openning Dummy Protocol 3")); RSocket sock; ret = sock.Open(ss,_L("Dummy Protocol 3")); TESTL(KErrNone == ret); // connecti socket TSockAddr addr; TRequestStatus stat; sock.Connect(addr, stat); User::WaitForRequest(stat); TESTL(KErrNone == stat.Int()); // drain MBuf Pool Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret); // send data and wait for 1/10 seconds Logger().WriteFormat(_L("Sending Data")); _LIT8( sendData, "bla bla bla bla"); sock.Send(sendData,0,stat); const TUint KTenMilliSecs = 10000; User::After(KTenMilliSecs); // free all mbufs Logger().WriteFormat(_L("Attempting to set KDummyOptionSetFreeMBufs Option in Protocol")); ret = sock.SetOpt(KDummyOptionSetFreeMBufs, 0, 0); TESTL(ret == KErrNone); Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret); // wait for send to return User::WaitForRequest(stat); Logger().WriteFormat(_L("Send has returned %d"), stat.Int()); if(stat.Int() != KErrNone) { verdict = EFail; } // recieve data and verify that it is the same as send data TBuf8<20> recvBuf; TRequestStatus recvStatus; sock.Recv(recvBuf, 0, recvStatus); User::WaitForRequest(recvStatus); Logger().WriteFormat(_L("recieving data on PDummy3 has returned %d"), recvStatus.Int()); if(recvStatus.Int() != KErrNone) { verdict = EFail; } Logger().WriteFormat(_L("Comparing Recieved data and Sent data"), recvStatus.Int()); if(recvBuf.Compare(sendData) == 0) { verdict = EPass; } sock.Close(); CleanupStack::PopAndDestroy(&ss); SetTestStepResult(verdict); return verdict; }
TInt CNcmCommunicationInterface::WriteInterruptData(TInt aEndPoint, TDesC8& aDes, TInt aLength) { OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_ENTRY, this ); TInt ret; RTimer timer; ret = timer.CreateLocal(); if ( ret ) { OstTrace1( TRACE_FATAL, CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA, "\ttimer.CreateLocal = %d- returning", ret); OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT, this ); return ret; } TRequestStatus status; TRequestStatus timerStatus; TEndpointBuffer epBuffer; ret = iPort.OpenEndpoint(epBuffer, aEndPoint); if (ret != KErrNone) { timer.Close(); OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP1, this ); return ret; } TAny *buf; TUint size; ret = epBuffer.GetInBufferRange(buf, size); if (ret != KErrNone) { timer.Close(); OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP2, this ); return ret; } else if (size < aLength) { timer.Close(); OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP3, this ); return KErrArgument; } TPtr8 writeBuf((TUint8 *)buf, size); writeBuf.Copy(aDes.Ptr(), aLength); ret = epBuffer.WriteBuffer(buf, writeBuf.Size(), ETrue, status); if (ret != KErrNone) { timer.Close(); OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP4, this ); return ret; } const TInt KWriteDataTimeout = 1000000; timer.After(timerStatus, KWriteDataTimeout); User::WaitForRequest(status, timerStatus); if ( timerStatus != KRequestPending ) { // Timeout occurred, silently ignore error condition. // Assuming that the line has been disconnected OstTrace0( TRACE_ERROR, CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA1, "CNcmCommunicationInterface::WriteInterruptData() - Timeout occurred"); iPort.WriteCancel(epBuffer.BufferNumber()); User::WaitForRequest(status); ret = timerStatus.Int(); } else { OstTrace0( TRACE_ERROR, CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA2, "CNcmCommunicationInterface::WriteInterruptData() - Write completed"); timer.Cancel(); User::WaitForRequest(timerStatus); ret = status.Int(); } epBuffer.Close(); timer.Close(); OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP5, this ); return ret; }
// --------------------------------------------------------------------------- // CTestStartupListUpdater::RemoveL() // --------------------------------------------------------------------------- // TInt CTestStartupListUpdater::RemoveL( CStifItemParser& aItem ) { _LIT( KTestName, "Remove" ); Print( 0, KTestStartFormat, &KTestName ); TInt testResult = KErrNone; RSoftwareComponentRegistry registry; User::LeaveIfError( registry.Connect() ); CleanupClosePushL( registry ); // Get installed application TComponentIds and TUids RArray<TUid> uidList; CleanupClosePushL( uidList ); RArray<TComponentId> componentIdList; CleanupClosePushL( componentIdList ); registry.GetComponentIdsL( componentIdList ); for( TInt i = 0; i < componentIdList.Count(); ++i ) { TComponentId compId = componentIdList[ i ]; CComponentEntry *compEntry = CComponentEntry::NewLC(); if( registry.GetComponentL( compId, *compEntry ) ) { if( compEntry->IsRemovable() && compEntry->SoftwareType() == KSoftwareTypeNative ) { _LIT(KCompUid, "CompUid"); CPropertyEntry *property = registry.GetComponentPropertyL( compId, KCompUid ); CleanupStack::PushL( property ); CIntPropertyEntry* intProperty = dynamic_cast<CIntPropertyEntry*>( property ); uidList.AppendL( TUid::Uid( intProperty->IntValue() ) ); CleanupStack::PopAndDestroy( property ); } else { uidList.AppendL( KNullUid ); } } CleanupStack::PopAndDestroy( compEntry ); } if( uidList.Count() != componentIdList.Count() ) { _LIT( KFailedToGetIds, "Failed to get IDs" ); Print( 0, KTestStartFormat, &KFailedToGetIds ); testResult = KErrGeneral; } // Uninstall TUid apps listed in parameters TPtrC param; while( aItem.GetNextString ( param ) == KErrNone && testResult == KErrNone ) { const TUint KMaxLimit = 0xFFFFFFFF; TLex lex( param ); TUint32 intVal = 0; _LIT( KHexPrefix, "0x" ); if( param.Left( KHexPrefix().Length() ) == KHexPrefix ) { lex.Inc( KHexPrefix().Length() ); testResult = lex.BoundedVal( intVal, EHex, KMaxLimit ); } else { testResult = lex.BoundedVal( intVal, EDecimal, KMaxLimit ); } if( testResult == KErrNone ) { TUid uid( TUid::Uid( intVal ) ); if( uid != KNullUid ) { TInt index = uidList.Find( uid ); if( index >= 0 && index < componentIdList.Count() ) { TComponentId componentId = componentIdList[ index ]; RSoftwareInstall installer; User::LeaveIfError( installer.Connect() ); CleanupClosePushL( installer ); TRequestStatus status; installer.Uninstall( componentId, status ); User::WaitForRequest( status ); testResult = status.Int(); CleanupStack::PopAndDestroy( &installer ); } else { testResult = KErrNotFound; } } else { testResult = KErrUnknown; } } Print( 1, KTestParamFormatArg, &KTestName, ¶m, testResult ); } CleanupStack::PopAndDestroy( 3, ®istry ); // componentIdList, uidList, registry Print( 0, KTestDoneFormat, &KTestName ); return testResult; }
TInt CTestDriveRemoteHangupDial::DriveETelApiL() /** * This method contains the real meat of the Client-side "Data Call answer and remote * hang-up closely followed by a dial" test code. This method sets up to answer a * call and receive a data transfer. The call is then terminated from the remote end, * and then must quickly respond by dialing the remote end back. Data is then * transfered and the call is terminated again from the remote end. * * @return KErrNone. */ { _LIT(KMmPhoneName,"GsmPhone1"); _LIT(KDataLineName,"Data"); INFO_PRINTF1(_L("Opening Mobile Phone\n")); RMobilePhone mmPhone; TESTL(mmPhone.Open(iServer,KMmPhoneName)==KErrNone); RLine line; INFO_PRINTF1(_L("Opening Data Line\n")); TESTL(line.Open(iPhone,KDataLineName)==KErrNone); INFO_PRINTF1(_L("Opening New Data Call\n")); RCall call; TESTL(call.OpenNewCall(line)==KErrNone); TRequestStatus reqStatus; RMobilePhone::TMMTableSettings tableSettings; tableSettings.iLocId=KInternetAccessPoint; RMobilePhone::TMMTableSettingsPckg tableSettingsPckg(tableSettings); iPhone.InitialiseMM(reqStatus , tableSettingsPckg); User::WaitForRequest(reqStatus); TESTL(reqStatus == KErrNone); // // Initialization complete // // Now wait for an incoming call... INFO_PRINTF1(_L("Wait to Answer incoming Data Call\n")); TESTL(call.AnswerIncomingCall()==KErrNone); INFO_PRINTF1(_L("Loan Data Call Port to Comm Server\n")); RCall::TCommPort commPort; TESTL(call.LoanDataPort(commPort)==KErrNone); RCommServ cs; TESTL(cs.Connect()==KErrNone); RComm port; TESTL(port.Open(cs,commPort.iPort,ECommShared)==KErrNone); // Transfer data TRequestStatus stat; port.Write(stat,KWriteTestRemoteHangupData); User::WaitForRequest(stat); TESTL(stat.Int()==KErrNone); //-- a small delay between successive writes to the COM port //-- I had to insert it to fix mistiming between script execution and sending AT-commands to modem User::After(500000); port.Write(stat,KWriteTestRemoteHangupData); User::WaitForRequest(stat); TESTL(stat.Int()==KErrNone); // Remote termination of call should have occurred in scripts, // close port and comm server port.Close(); cs.Close(); INFO_PRINTF1(_L("Reclaim Data Call Port from Comm Server\n")); TESTL(call.RecoverDataPort()==KErrNone); // Now perform the user specified delay before making outgoing call... INFO_PRINTF2(_L("Start the %d sec delay before making outgoing call\n"), iVarDelay); User::After( (TTimeIntervalMicroSeconds32)(iVarDelay*1000000L) ); INFO_PRINTF2(_L("End of the delay before making outgoing call\n"), iVarDelay); // Now perform the outgoing call... // dial _LIT(KDialString,"+1234"); TESTL(call.Dial(KDialString)==KErrNone); INFO_PRINTF1(_L("Loan Data Call Port to Comm Server\n")); TESTL(call.LoanDataPort(commPort)==KErrNone); TESTL(cs.Connect()==KErrNone); TESTL(port.Open(cs,commPort.iPort,ECommShared)==KErrNone); // Transfer data port.Write(stat,KWriteTestRemoteHangupData2); User::WaitForRequest(stat); TESTL(stat.Int()==KErrNone); //-- a small delay between successive writes to the COM port //-- I had to insert it to fix mistiming between script execution and sending AT-commands to modem User::After(500000); port.Write(stat,KWriteTestRemoteHangupData2); User::WaitForRequest(stat); TESTL(stat.Int()==KErrNone); // Remote termination of call should have occurred in scripts, // close port and comm server port.Close(); cs.Close(); INFO_PRINTF1(_L("Reclaim Data Call Port from Comm Server\n")); TESTL(call.RecoverDataPort()==KErrNone); TInt32 ss; TInt8 bar=0; mmPhone.GetSignalStrength(stat,ss,bar); User::WaitForRequest(stat); TESTL(stat==KErrNone); // close iPhone, line and call mmPhone.Close(); line.Close(); call.Close(); return KErrNone; }
TVerdict CPsyDisabledStep::doTestStepL() /** * @return - TVerdict code * Override of base class pure virtual * Our implementation only gets called if the base class doTestStepPreambleL() did * not leave. That being the case, the current test result value will be EPass. */ { StandardPrepareL(); InitPsySettingsL(3, KNetworkPsy1, 1, KIntGpsPsy1, 1, KNetworkPsy2, 1); ConfigPsyL(KNetworkPsy1, 1, KConfigLRNoError10s //Step1. no error in 10s ); ConfigPsyL(KIntGpsPsy1, 2, KConfigLRNoError, //Step 1. no error KConfigLRNoError10s //Step 2. no error in 10s ); ConfigPsyL(KNetworkPsy2, 1, KConfigLRNoError //Step2. no error ); User::After(KSecond*7); TRequestStatus status; TPositionInfo posInfo; TPositionUpdateOptions options; //1. Disable PSY1 while location request is on going. LR shall //fallback to PSY2 and then fix from PSY2 is used. iPositioner.NotifyPositionUpdate(posInfo, status); User::After(KTinyDelay); SET_TIME ToggleModuleL(KNetworkPsy1, EFalse); User::WaitForRequest(status); //CHECK_TIME(1) CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest); CheckExpectedResult(posInfo.ModuleId(), KIntGpsPsy1, KWrongModuleIdReturned); ToggleModuleL(KNetworkPsy1, ETrue); //Config PSY1 again since it was unloaded when it was disabled. ConfigPsyL(KNetworkPsy1, 1, KConfigLRNoError20s //Step2. no error in 20s ); User::After(KSecond*7); //2. Disable PSY2 while location request ongoing, the request shall //fallbck to PSY3 SET_TIME iPositioner.NotifyPositionUpdate(posInfo, status); User::After(KSecond*15); //after 15s disable PSY2 ToggleModuleL(KIntGpsPsy1, EFalse); User::WaitForRequest(status); CHECK_TIME(16) //After PSY2 is disabled in 15 seconds, PSY3 is used. CheckExpectedResult(status.Int(), KErrNone, KFailedPositionRequest); CheckExpectedResult(posInfo.ModuleId(), KNetworkPsy2, KWrongModuleIdReturned); // cleanup StandardCleanup(); return TestStepResult(); }
// --------------------------------------------------------- // CPosTp154::PrintParsedDataFromEncoderL // // (other items were commented in a header). // --------------------------------------------------------- // void CPosTp154::PrintParsedDataFromEncoderL( const TDesC& aFile, const TDesC8& aBuffer, TInt aExpectedStatusCode, const TDesC8& aMimeType) { iLog->Log(_L("===== PrintParsedDataFromEncoderL =======")); iLandmarkParser = CPosLandmarkParser::NewL(aMimeType); if (aFile != KNullDesC) { TFileName file( aFile ); iLog->Log(_L("FILE (%S)"), &file ); TraceL(_L("----->Using FILE<-------")); TraceL(file); iLandmarkParser->SetInputFileL(file); } else { iLog->Log(_L("BUFFER (size %d)"), aBuffer.Size() ); TraceL(_L("----->Using BUFFER<-------")); iLandmarkParser->SetInputBuffer(aBuffer); } iOperation = iLandmarkParser->ParseContentL(); TRequestStatus status = KPosLmOperationNotComplete; TReal32 progress; TInt number = 0; RArray<TPosLmItemId> array; CleanupClosePushL(array); while (status == KPosLmOperationNotComplete) { iLog->Log(_L("--- Parsing ---------------------------")); TraceL(_L("------------------------------")); iOperation->NextStep(status, progress); // Wait for NextStep to complete User::WaitForRequest(status); if (status != KPosLmOperationNotComplete && status != KErrNone) { iLog->Log(_L("Parsing Complete")); HBufC* buffer = HBufC::NewLC( 128); TPtr buf = buffer->Des(); buf.Format(_L("\tStatus %d"), status.Int()); iLog->Log(buf); TraceL(buf); CleanupStack::PopAndDestroy( buffer ); buffer = NULL; } else { iLog->Log(_L("Parsing element")); if ( iLandmarkParser->NumOfParsedLandmarks() ) { // Get last parsed landmark CPosLandmark* lm = iLandmarkParser->LandmarkLC(); TPtrC lmName; TPtrC catName; lm->GetLandmarkName(lmName); lm->GetCategoriesL(array); //iLog->Log(lmName); for (TInt i=0;i<array.Count();i++) { CPosLandmarkCategory* category = iLandmarkParser->LandmarkCategoryLC( array[i] ); category->GetCategoryName( catName ); HBufC* buffer = HBufC::NewLC( 128 + catName.Length()); TPtr buf = buffer->Des(); if ( category->GlobalCategory()) { buf.Append(_L("\tGlobal category: ")); } else { buf.Append(_L("\tLocal category: ")); } buf.Append(catName); iLog->Log(buf); TraceL(buf); CleanupStack::PopAndDestroy( buffer ); buffer = NULL; CleanupStack::PopAndDestroy(category); } PrintLandmarkFieldsWithDescriptionL(*lm, ETrue); number++; CleanupStack::PopAndDestroy(lm); } } } iLog->Log(_L("--- Parsing end ---------------------------")); TraceL(_L("------------------------------")); CleanupStack::PopAndDestroy(&array); if (status.Int() != aExpectedStatusCode) { HBufC* buffer = HBufC::NewLC( 128 ); TPtr buf = buffer->Des(); buf.Format(_L("\tERROR: Wrong status returned, was %d, should be %d"), status.Int(), aExpectedStatusCode); iLog->Log( buf ); iErrorsFound++; CleanupStack::PopAndDestroy( buffer ); buffer = NULL; } TUint32 nr = iLandmarkParser->NumOfParsedLandmarks(); HBufC* buffer = HBufC::NewLC( 256 ); TPtr buf = buffer->Des(); buf.Format(_L("\tNr of Parsed landmarks %d, should be %d"), nr, number); iLog->Log(buf); TraceL(buf); CleanupStack::PopAndDestroy( buffer ); buffer = NULL; if (nr != (TUint32)number) { iLog->Log(_L("\tERROR: Wrong number of landmarks parsed returned!")); iErrorsFound++; } TPosLmCollectionDataId lmId = iLandmarkParser->FirstCollectionDataId(); iLog->Log(_L("--- CollectionData ---")); TraceL(_L("--- CollectionData ---")); if (lmId != EPosLmCollDataNone) { TPtrC first = iLandmarkParser->CollectionData(lmId); HBufC* buffer = HBufC::NewLC( first.Length() + 256 ); TPtr buf = buffer->Des(); buf.Zero(); buf.Format(_L("\t(1)Collection Id: %d CollectionData: "), lmId); buf.Append(first); iLog->Log(buf); TraceL(buf); CleanupStack::PopAndDestroy( buffer ); buffer = NULL; } else { iLog->Log(_L("\tNo collection data found 1")); } while (lmId != EPosLmCollDataNone) { lmId = iLandmarkParser->NextCollectionDataId(lmId); if (lmId != EPosLmCollDataNone) { TPtrC first = iLandmarkParser->CollectionData(lmId); HBufC* buffer = HBufC::NewLC( first.Length() + 256 ); TPtr buf = buffer->Des(); buf.Zero(); buf.Format(_L("\t(2)Collection Id: %d CollectionData: "), lmId); buf.Append(first); iLog->Log(buf); TraceL(buf); CleanupStack::PopAndDestroy( buffer ); buffer = NULL; } else { iLog->Log(_L("\tNo collection data found 2")); } } iLog->Log(_L("--- CollectionData ---")); TraceL(_L("--- CollectionData ---")); delete iOperation; iOperation = NULL; delete iLandmarkParser; iLandmarkParser = NULL; iLog->Log(_L("====== PrintParsedDataFromEncoderL Done ========\n")); }
// --------------------------------------------------------- // CT_LbsClientPosTp178::StartL // // (other items were commented in a header). // --------------------------------------------------------- // void CT_LbsClientPosTp178::StartL() { _LIT(KServiceAccept, "SAAA"); SetupPsyL(iUidTestPsy3); RPositioner positioner; TPositionInfo info = TPositionInfo(); ConnectL(); User::LeaveIfError(positioner.Open(iPosServer,iUidTestPsy3)); CleanupClosePushL(positioner); TInt Err = positioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KServiceAccept); TPositionUpdateOptions updateOptionsLong, updateOptionsShort; TTimeIntervalMicroSeconds longInterval(7000000); updateOptionsLong.SetUpdateTimeOut(longInterval); Err = positioner.SetUpdateOptions(updateOptionsLong); TTimeIntervalMicroSeconds shortInterval(2000000); updateOptionsShort.SetUpdateTimeOut(shortInterval); TPositionUpdateOptions theUpdateOptions; Err = positioner.GetUpdateOptions(theUpdateOptions); if (theUpdateOptions.UpdateTimeOut() != updateOptionsLong.UpdateTimeOut() || updateOptionsLong.UpdateTimeOut() != longInterval) { _LIT(KUpdateOptions, "The update option was not set correctly"); LogErrorAndLeaveL(KUpdateOptions); } _LIT(KDelayMsg, "The successfull requests was completed within %d microsecs."); _LIT(KCancelMsg, "The canceled requests was completed within %d microsecs."); TRequestStatus status; for (TInt i = 0; i < 10; i++) // makes 10 test inorder to get some statistic { positioner.SetUpdateOptions(updateOptionsLong); TTime requestStartTime; requestStartTime.UniversalTime(); positioner.NotifyPositionUpdate(info, status); User::WaitForRequest(status); TTime requestStopTime; requestStopTime.UniversalTime(); TTimeIntervalMicroSeconds durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime); TInt duration = durationMicro.Int64(); TBuf<100> timeMsg; timeMsg.Format(KDelayMsg, duration); INFO_PRINTF1(timeMsg); //check error status if (status != KErrNone) { _LIT(KErrPositionRequest, "error code returned from NotifyPositionUpdate, error code = %d"); TBuf<100> buf; buf.Format(KErrPositionRequest, status.Int()); LogErrorAndLeaveL(buf); } TTimeIntervalMicroSeconds shortInterval(2000000); updateOptionsShort.SetUpdateTimeOut(shortInterval); positioner.SetUpdateOptions(updateOptionsShort); requestStartTime.UniversalTime(); positioner.NotifyPositionUpdate(info, status); User::WaitForRequest(status); requestStopTime.UniversalTime(); durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime); duration = durationMicro.Int64(); #ifdef __WINS__ TTimeIntervalMicroSeconds winsFail(100000); durationMicro = TTimeIntervalMicroSeconds(durationMicro.Int64()+winsFail.Int64()); #endif timeMsg.Format(KCancelMsg, duration); INFO_PRINTF1(timeMsg); if (status != KErrTimedOut) { _LIT(KErrPositionRequest, "Request did not returned KErrTimedOut, status code = %d."); TBuf<100> buf; buf.Format(KErrPositionRequest, status.Int()); LogErrorAndLeaveL(buf); } //Check that the request was not aborted before the Interval //Remove this condition if a lot of data is needed in test log. if (durationMicro < shortInterval) { _LIT(KErrInterval, " The request was aborted before the set timed out "); LogErrorAndLeaveL(KErrInterval); } } // end for loop CleanupStack::PopAndDestroy(1); //positioner Disconnect(); // Do timeout test TestTimeoutL(); // Do cancel test TestCancelL(); // ESLI-5QRA7U just check that it is not possible to set a timeout that is less than // the update interval TestOptionL(); }
enum TVerdict CEsockTest10_1::easyTestStepL() { TESTL(EPass == TestStepResult()); TPckgBuf<TUint> flags; // get select state of server socket TRequestStatus stat; flags() = KSockSelectRead | KSockSelectWrite | KSockSelectExcept; iEsockSuite->GetSocketHandle(iSockIndex3).Ioctl(KIOctlSelect, stat, &flags, KSOLSocket); User::WaitForRequest(stat); TESTL(stat==KErrNone); TESTL(flags()==KSockSelectWrite); // send data from client to server (2 bytes, 1 urgent) TInt ret = iEsockSuite->GetSocketHandle(iSockIndex2).SetOpt(KSoTcpNextSendUrgentData, KSolInetTcp, 1); TESTEL(KErrNone == ret, ret); iEsockSuite->GetSocketHandle(iSockIndex2).Write(_L8("12"), stat); User::WaitForRequest(stat); TESTEL(stat==KErrNone, stat.Int()); // delay for 1 second User::After(1000000); // get select state of the server socket flags() = KSockSelectRead | KSockSelectWrite | KSockSelectExcept; iEsockSuite->GetSocketHandle(iSockIndex3).Ioctl(KIOctlSelect, stat, &flags, KSOLSocket); User::WaitForRequest(stat); TESTL(stat==KErrNone); TESTL(flags()==(KSockSelectRead | KSockSelectWrite | KSockSelectExcept)); // read data (server) TBuf8<20> rbuf2; iEsockSuite->GetSocketHandle(iSockIndex3).Read(rbuf2, stat); User::WaitForRequest(stat); TESTEL(stat==KErrUrgentData, stat.Int()); // get select state of the server socket flags() = KSockSelectRead | KSockSelectWrite | KSockSelectExcept; iEsockSuite->GetSocketHandle(iSockIndex3).Ioctl(KIOctlSelect, stat, &flags, KSOLSocket); User::WaitForRequest(stat); TESTL(stat==KErrNone); TESTL(flags()==(KSockSelectWrite | KSockSelectExcept)); // read the urgent data byte TInt nRet; ret = iEsockSuite->GetSocketHandle(iSockIndex3).GetOpt(KSoTcpReadUrgentData, KSolInetTcp, nRet); TESTEL(KErrNone == ret, ret); TESTL(nRet=='2'); ret = iEsockSuite->GetSocketHandle(iSockIndex3).GetOpt(KSoTcpReadUrgentData, KSolInetTcp, nRet); TESTEL(KErrNotFound == ret, ret); // get select state of the server socket flags() = KSockSelectRead | KSockSelectWrite | KSockSelectExcept; iEsockSuite->GetSocketHandle(iSockIndex3).Ioctl(KIOctlSelect, stat, &flags, KSOLSocket); User::WaitForRequest(stat); TESTL(stat==KErrNone); TESTL(flags()==KSockSelectWrite); return EPass; }
void CCTsyPrivacyFU::DoNotifyPrivacyConfirmationL(const TDesC& aLineName) { OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); RLine line; RMobileCall mobileCall; TInt err = line.Open(iPhone, aLineName); ASSERT_EQUALS(KErrNone, err) CleanupClosePushL(line); err = mobileCall.OpenNewCall(line); ASSERT_EQUALS(KErrNone, err) CleanupClosePushL(mobileCall); //------------------------------------------------------------------------- // TEST C: Successful completion request of // RMobileCall::NotifyPrivacyConfirmation when result is not cached. //------------------------------------------------------------------------- // invoke RMobilePhone::NotifyPrivacyConfirmation TRequestStatus notifyStatus; // initialize the variable to be set by CTSY with the value other than passed to MockLTSY RMobilePhone::TMobilePhonePrivacy privacy = RMobilePhone::EPrivacyOn; mobileCall.NotifyPrivacyConfirmation(notifyStatus,privacy); // prepare the data to be returned from MockLTSY RMobilePhone::TMobilePhonePrivacy privacySetting = RMobilePhone::EPrivacyUnspecified; TMockLtsyCallData1<RMobilePhone::TMobilePhonePrivacy> privacySettingData(privacySetting); RBuf8 data; CleanupClosePushL(data); privacySettingData.SerialiseL(data); // trigger EMobileCallNotifyPrivacyConfirmation completion via MockLTSY TRequestStatus mockLtsyStatus; iMockLTSY.NotifyTerminated(mockLtsyStatus); iMockLTSY.CompleteL(EMobileCallNotifyPrivacyConfirmation, KErrNone,data); User::WaitForRequest(mockLtsyStatus); ASSERT_EQUALS(KErrNone,mockLtsyStatus.Int()); // wait for RMobilePhone::NotifyPrivacyConfirmation completion User::WaitForRequest(notifyStatus); ASSERT_EQUALS(KErrNone,notifyStatus.Int()); ASSERT_EQUALS(RMobilePhone::EPrivacyUnspecified, privacy); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST E: Unsolicited completion of RMobileCall::NotifyPrivacyConfirmation // from LTSY. //------------------------------------------------------------------------- iMockLTSY.NotifyTerminated(mockLtsyStatus); iMockLTSY.CompleteL(EMobileCallNotifyPrivacyConfirmation, KErrNone,data); User::WaitForRequest(mockLtsyStatus); ASSERT_EQUALS(KErrNone,mockLtsyStatus.Int()); AssertMockLtsyStatusL(); CleanupStack::PopAndDestroy(4, this); // data, mobileCall, line, this }
TVerdict CTestDevVideoPlayClock::DoTestStepL() { TVerdict ret = EPass; TTimeIntervalMicroSeconds testTime(0); TUint timeUint = 0; iClockSource = CSystemClockSource::NewL(); // Construct a new thread to constantly probe the clock - to test that it'll work from multiple threads RThread thread; TInt error = thread.Create(_L("ClockSourceTestThread"), &CTestDevVideoPlayClock::StartThread, KDefaultStackSize, &User::Heap(), static_cast<TAny*>(this), EOwnerThread); if (error) { ERR_PRINTF1(_L("Error - Couldn't create periodic utility object")); delete iClockSource; return EInconclusive; } TRequestStatus stat; thread.Logon(stat); if (stat!=KRequestPending) { delete iClockSource; ERR_PRINTF2(_L("Error - Couldn't logon to the thread err=%d"), stat.Int()); thread.LogonCancel(stat); User::WaitForRequest(stat); return EInconclusive; } thread.SetPriority(EPriorityLess); // wait for system to calm down User::After(KTestClock2Seconds); // reset the clock iClockSource->Reset(); thread.Resume(); // wait for 2 seconds and then check the time == 2 seconds User::After(KTestClock2Seconds); testTime = iClockSource->Time(); timeUint = I64LOW(testTime.Int64()); if (!TimeComparison(timeUint, KTestClock2Seconds, KTestClockDeviationMS)) { ERR_PRINTF3(_L("Error - time comparison failed: Got %u; Expected %u"), timeUint, KTestClock2Seconds); ret = EFail; } else { INFO_PRINTF3(_L("Time comparison passed: Got %u; Expected %u"), timeUint, KTestClock2Seconds); } // reset the clock back to 2 seconds //testTime = KTestClock2Seconds; //iClockSource->Reset(testTime); // suspend timer for 2 seconds then resume for 2 seconds iClockSource->Suspend(); User::After(KTestClock2Seconds); iClockSource->Resume(); User::After(KTestClock2Seconds); testTime = iClockSource->Time(); timeUint = I64LOW(testTime.Int64()); if (!TimeComparison(timeUint, KTestClock4Seconds, KTestClockDeviationMS)) { ERR_PRINTF3(_L("Error - Suspend() + Resume() time comparison failed: Got %u; Expected %u"), timeUint, KTestClock4Seconds); ret = EFail; } else { INFO_PRINTF3(_L("Suspend() + Resume() time comparison passed: Got %u; Expected %u"), timeUint, KTestClock4Seconds); } // reset clock to 18 seconds testTime = KTestClock18Seconds; iClockSource->Reset(testTime); // wait for 2 seconds and then check the time == 20 seconds User::After(KTestClock2Seconds); testTime = iClockSource->Time(); timeUint = I64LOW(testTime.Int64()); if (!TimeComparison(timeUint, KTestClock20Seconds, KTestClockDeviationMS)) { ERR_PRINTF3(_L("Error - Reset() time comparison failed: Got %u; Expected %u"), timeUint, KTestClock20Seconds); ret = EFail; } else { INFO_PRINTF3(_L("Reset() time comparison passed: Got %u; Expected %u"), timeUint, KTestClock20Seconds); } // suspend for 2 seconds then resume for 2 seconds iClockSource->Suspend(); User::After(KTestClock2Seconds); iClockSource->Resume(); User::After(KTestClock2Seconds); testTime = iClockSource->Time(); timeUint = I64LOW(testTime.Int64()); if (!TimeComparison(timeUint, KTestClock22Seconds, KTestClockDeviationMS)) { ERR_PRINTF3(_L("Error - Suspend() + Resume() time comparison failed: Got %u; Expected %u"), timeUint, KTestClock22Seconds); ret = EFail; } else { INFO_PRINTF3(_L("Suspend() + Resume() time comparison passed: Got %u; Expected %u"), timeUint, KTestClock22Seconds); } // Now test the periodic utility TRAPD(perError, iPeriodicUtility = CMMFClockSourcePeriodicUtility::NewL(*iClockSource, *this)); if (perError) { ERR_PRINTF1(_L("Error - Couldn't create periodic utility object")); ret = EInconclusive; } else { iPeriodicUtilityTestVerdict = EPass; TTimeIntervalMicroSeconds32 period = KTestClock2Seconds; iClockSource->Reset(); iPeriodicUtility->Start(period); CActiveScheduler::Start(); ret = iPeriodicUtilityTestVerdict; } delete iPeriodicUtility; iPeriodicUtility = NULL; // Clean up the thread iShutdownSubthread = ETrue; User::WaitForRequest(stat); thread.Close(); delete iClockSource; return ret; }
enum TVerdict CZCDriverTestStep::doTestStepL() { CActiveScheduler* activeScheduler = new(ELeave) CActiveScheduler; CleanupStack::PushL(activeScheduler); CActiveScheduler::Install(activeScheduler); SetTestStepResult(EFail); // Start of testing INFO_PRINTF1(_L("Load Physical Device")); TInt r; r=User::LoadPhysicalDevice(KZeroCopyLoopbackPddFileName); TEST_VERDICT(r==KErrNone || r==KErrAlreadyExists); INFO_PRINTF1(_L("Load Logical Device")); r=User::LoadLogicalDevice(KZeroCopyLoopbackLddFileName); TEST_VERDICT(r==KErrNone || r==KErrAlreadyExists); // Initialize a commsbuf pond RCommsBufPondOp commsBufPond; RArray<TCommsBufPoolCreateInfo> createInfos; TCommsBufPoolCreateInfo poolInfoForLargeBufs; poolInfoForLargeBufs.iBufSize = KMBuf_MBufSizeBig; poolInfoForLargeBufs.iInitialBufs = KMBuf_InitialAllocation; poolInfoForLargeBufs.iGrowByBufs = KMBuf_MinGrowth; poolInfoForLargeBufs.iMinFreeBufs = KMBuf_GrowthThreshold; poolInfoForLargeBufs.iCeiling = (KMBuf_MaxAvail/2) / KMBuf_MBufSize; createInfos.AppendL(poolInfoForLargeBufs); TCommsBufPoolCreateInfo poolInfoForSmallBufs; poolInfoForSmallBufs.iBufSize = KMBuf_MBufSize; poolInfoForSmallBufs.iInitialBufs = KMBuf_InitialAllocation; poolInfoForSmallBufs.iGrowByBufs = KMBuf_MinGrowth; poolInfoForSmallBufs.iMinFreeBufs = KMBuf_GrowthThreshold; poolInfoForSmallBufs.iCeiling = (KMBuf_MaxAvail/2) / KMBuf_MBufSize; createInfos.AppendL(poolInfoForSmallBufs); User::LeaveIfError(commsBufPond.Open(createInfos)); createInfos.Close(); __KHEAP_MARK; INFO_PRINTF1(_L("Open Device")); RDevice device; r=device.Open(RZeroCopyLoopbackDriver::Name()); TEST_VERDICT(r==KErrNone); INFO_PRINTF1(_L("Get Device Capabilities")); RZeroCopyLoopbackDriver::TCaps caps; TPckg<RZeroCopyLoopbackDriver::TCaps>capsPckg(caps); capsPckg.FillZ(); // Zero 'caps' so we can tell if GetCaps has really filled it device.GetCaps(capsPckg); TVersion expectedVer(RZeroCopyLoopbackDriver::VersionRequired()); TEST_VERDICT(caps.iVersion.iMajor==expectedVer.iMajor); TEST_VERDICT(caps.iVersion.iMinor==expectedVer.iMinor); TEST_VERDICT(caps.iVersion.iBuild==expectedVer.iBuild); INFO_PRINTF1(_L("Close Device")); device.Close(); INFO_PRINTF1(_L("Open Logical Channel")); RZeroCopyLoopbackDriver ldd; r=ldd.Open(); TEST_VERDICT(r==KErrNone); INFO_PRINTF1(_L("GetConfig")); RZeroCopyLoopbackDriver::TConfigBuf configBuf; configBuf.FillZ(); // Zero 'config' so we can tell if GetConfig has really filled it r=ldd.GetConfig(configBuf); TEST_VERDICT(r==KErrNone); RZeroCopyLoopbackDriver::TConfig& config=configBuf(); TEST_VERDICT(config.iPddBufferSize!=0); TEST_VERDICT(config.iMaxSendDataSize!=0); TEST_VERDICT(config.iMaxReceiveDataSize!=0); INFO_PRINTF1(_L("SetConfig")); TInt speed = configBuf().iSpeed+1; configBuf().iSpeed = speed; r=ldd.SetConfig(configBuf); // Use SetConfig to change speed TEST_VERDICT(r==KErrNone); configBuf.FillZ(); r=ldd.GetConfig(configBuf); TEST_VERDICT(r==KErrNone); TEST_VERDICT(configBuf().iSpeed==speed); TRequestStatus status; INFO_PRINTF1(_L("Check access by wrong client")); RZeroCopyLoopbackDriver ldd2=ldd; r=ldd2.Duplicate(RThread(),EOwnerProcess); TEST_VERDICT(r==KErrAccessDenied); INFO_PRINTF1(_L("Check handle duplication")); ldd2=ldd; r=ldd2.Duplicate(RThread(),EOwnerThread); TEST_VERDICT(r==KErrNone); ldd2.Close(); INFO_PRINTF1(_L("Load pond")); r = ldd.LoadPond(commsBufPond); TEST_VERDICT(r == KErrNone); INFO_PRINTF1(_L("Unload pond")); r = ldd.UnloadPond(); TEST_VERDICT(r == KErrNone); INFO_PRINTF1(_L("Reload pond")); r = ldd.LoadPond(commsBufPond); TEST_VERDICT(r == KErrNone); INFO_PRINTF1(_L("SendData")); TCommsBufAllocator allocator = commsBufPond.Allocator(); RCommsBuf* buf = RCommsBuf::Alloc(KTestSendData().Length(), allocator); TEST_VERDICT(buf != NULL); buf->Reset(); buf->Append(KTestSendData); ldd.SendData(status, *buf); User::WaitForRequest(status); r = status.Int(); TEST_VERDICT(r == KErrNone); buf = NULL; INFO_PRINTF1(_L("SendData")); buf = RCommsBuf::Alloc(KTestSendData().Length(), allocator); TEST_VERDICT(buf != NULL); buf->Reset(); buf->Append(KTestSendData); ldd.SendData(status, *buf); User::WaitForRequest(status); r=status.Int(); TEST_VERDICT(r == KErrNone); buf = NULL; INFO_PRINTF1(_L("ReceiveData")); RCommsBuf* rxbuf; ldd.ReceiveData(status); User::WaitForRequest(status); r=status.Int(); TEST_VERDICT(r > 0); rxbuf = commsBufPond.FromHandle(r); TEST_VERDICT(rxbuf != 0); TEST_VERDICT(rxbuf->Length() == KTestSendData().Size()); TEST_VERDICT(rxbuf->DesC8() == KTestSendData); TBuf8<256> bufdata; rxbuf->Read(bufdata); TEST_VERDICT(bufdata == KTestSendData); rxbuf->Free(); rxbuf = NULL; INFO_PRINTF1(_L("ReceiveData")); ldd.ReceiveData(status); User::WaitForRequest(status); r=status.Int(); TEST_VERDICT(r > 0); rxbuf = commsBufPond.FromHandle(r); TEST_VERDICT(rxbuf != 0); TEST_VERDICT(rxbuf->Length() == KTestSendData().Size()); TEST_VERDICT(rxbuf->DesC8() == KTestSendData); rxbuf->Read(bufdata); TEST_VERDICT(bufdata == KTestSendData); rxbuf->Free(); rxbuf = NULL; INFO_PRINTF1(_L("ReceiveDataCancel")); ldd.ReceiveData(status); User::After(KOneSecond); ldd.ReceiveDataCancel(); User::WaitForRequest(status); r=status.Int(); TEST_VERDICT(r == KErrCancel); #if 0 INFO_PRINTF1(_L("SendDataCancel")); ldd.SendDataCancel(); User::WaitForRequest(status); r=status.Int(); TEST_VERDICT(r == KErrNone); buf = NULL; #endif INFO_PRINTF1(_L("Unload pond")); r = ldd.UnloadPond(); TEST_VERDICT(r == KErrNone); INFO_PRINTF1(_L("Close Logical Channel")); ldd.Close(); __KHEAP_MARKEND; INFO_PRINTF1(_L("Unload Logical Device")); r=User::FreeLogicalDevice(RZeroCopyLoopbackDriver::Name()); TEST_VERDICT(r==KErrNone); INFO_PRINTF1(_L("Unload Physical Device")); TName pddName(RZeroCopyLoopbackDriver::Name()); _LIT(KVariantExtension,".template"); pddName.Append(KVariantExtension); r=User::FreePhysicalDevice(pddName); TEST_VERDICT(r==KErrNone); // Close the pond commsBufPond.Close(); // End of testing CleanupStack::PopAndDestroy(activeScheduler); SetTestStepResult(EPass); return TestStepResult(); }
TInt CSenBaseIdentityManager::AuthenticationForL( CSenIdentityProvider& aProvider, TPckgBuf<TSenAuthentication>& aResponse) { TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CSenBaseIdentityManager::AuthenticationForL"); TPtrC8 user = aProvider.AuthzID(); if (user == KNullDesC8) { user.Set(aProvider.AdvisoryAuthnID()); } if (!iShowPasswordDialog) { TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"Not allowed to show password dialog"); HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password()); TPtrC8 decodedPassword = pDecodedPassword->Des(); aResponse().iUsername.Append((const TUint8*)user.Ptr(), user.Size()); aResponse().iPassword.Append((const TUint8*)decodedPassword.Ptr(), decodedPassword.Size()); CleanupStack::PopAndDestroy(); // delete pDecodedPassword return KErrNone; } RNotifier notifier; User::LeaveIfError(notifier.Connect()); CleanupClosePushL(notifier); TPckgBuf<TAuthenticationDlgRequest>* request = new(ELeave)TPckgBuf<TAuthenticationDlgRequest>(); CleanupStack::PushL(request); // convert username to unicode HBufC* pUserAsUnicode = SenXmlUtils::ToUnicodeLC(user); // push TPtrC username = pUserAsUnicode->Des(); // decode password HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password()); TPtrC8 decodedPassword = pDecodedPassword->Des(); // convert decoded password to unicode HBufC* pPasswordAsUnicode = SenXmlUtils::ToUnicodeLC(decodedPassword); // push TPtrC password = pPasswordAsUnicode->Des(); // set data to request (*request)().SetData(username, password); CleanupStack::PopAndDestroy(3); // delete pPasswordAsUnicode, pDecodedPassword, pUserAsUnicode TPckgBuf<TAuthenticationDlgResponse>* response = new(ELeave)TPckgBuf<TAuthenticationDlgResponse>(); CleanupStack::PushL(response); TRequestStatus reqStatus; notifier.StartNotifierAndGetResponse(reqStatus, KSenNotifierPluginUID, *request, *response); TBool illegalUsername = EFalse; HBufC8* pUsernameUtf8 = NULL; HBufC8* pPasswordUtf8 = NULL; User::WaitForRequest(reqStatus); notifier.Close(); if(reqStatus.Int() == KErrNone) { if((*response)().OkButtonPressed()) { TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("User pressed OK Button in Password dialog"))); pUsernameUtf8 = SenXmlUtils::ToUtf8LC((*response)().Username()); pPasswordUtf8 = SenXmlUtils::ToUtf8LC((*response)().Password()); TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Username: %S"), pUsernameUtf8)); TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Password: %S"), pPasswordUtf8 )); HBufC8* pEncodedUsername = NULL; illegalUsername = SenXmlUtils::EncodeHttpCharactersL(*pUsernameUtf8, pEncodedUsername); if (illegalUsername) { TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("Username included illegal characters."))); delete pEncodedUsername; pEncodedUsername = NULL; } #ifdef _SENDEBUG else { TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"Username did NOT include illegal characters."); } #endif //Check if iilegal chars are there then return if (!illegalUsername) { if(user != *pUsernameUtf8) { // User modified the username in the dialog prompt(!) // We have to save it right away, because there is // no in-memory/session based member variables in // components calling identity manager (sec mechs and // in ID-WSF AS client! TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"Username changed. Saving new username."); // Use Advisory only if AuthzID is not available if (aProvider.AuthzID() == KNullDesC8 && aProvider.AdvisoryAuthnID() != KNullDesC8) { aProvider.SetUserInfoL(aProvider.AuthzID(), *pUsernameUtf8, aProvider.Password()); } else { // There was at least AuthzID available, and possibly // also advisory value. Any way, if // We have to NULL advisory value (set it to KNullDesC8), // because if both were available, then user was // prompted to allow modification of AuthzID AND // if advisory was changed in service (is no longer // valid), there would NOT be any way for end-user // to change (remove) it(!) CSenElement& element = aProvider.AsElement(); delete element.RemoveElement(KSenIdpAdvisoryAuthnIdLocalname); aProvider.SetUserInfoL(*pUsernameUtf8, KNullDesC8, aProvider.Password()); } // serialize changed username into sensessions.xml database immediately WriteDatabase(); } if (AllowSavePasswordL()) { HBufC8* pEncodedPassword = SenXmlUtils::EncodeHttpCharactersLC(*pPasswordUtf8); #ifdef _SENDEBUG if(pEncodedPassword) { TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Encoded password: %S"), pEncodedPassword)); } #endif if(pEncodedPassword) { aProvider.SetUserInfoL(aProvider.AuthzID(), aProvider.AdvisoryAuthnID(), *pEncodedPassword); } WriteDatabase(); CleanupStack::PopAndDestroy(1); // pEncodedPassword } } aResponse().iUsername.Zero(); aResponse().iPassword.Zero(); if (!illegalUsername) { aResponse().iUsername.Copy(pUsernameUtf8->Des()); aResponse().iPassword.Copy(pPasswordUtf8->Des()); } CleanupStack::PopAndDestroy(2); // pPasswordUtf8, pUsernameUtf8 } else { TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("User pressed Cancel Button in Password dialog"))); } } else if(reqStatus.Int() == KErrNotFound) { TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("Password dialog plugin notifier impl. was not found"))); } else { TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8(" Notifier plugin for 'Password' dialog returned an error: %d"), reqStatus.Int())); } CleanupStack::PopAndDestroy(2); // request, response; CleanupStack::Pop(); // notifier if (illegalUsername) return KErrArgument; return reqStatus.Int(); }
enum TVerdict CEsockTest29_10::easyTestStepL( void ) { SetTestStepResult(EFail); TInt ret; const TUint KOneSecond = 1000000; Logger().WriteFormat(_L("Send/ Recv on PDummy3 socket but no avail MBuf Memory, mBuf becomes avail after send")); RSocketServ ss; ret = ss.Connect(); TESTL(KErrNone == ret); // open dummy prot 3 Logger().WriteFormat(_L("Openning Dummy Protocol 3")); RSocket sock; ret = sock.Open(ss,_L("Dummy Protocol 3")); TESTL(KErrNone == ret); // connect socket TSockAddr addr; TRequestStatus connStat; sock.Connect(addr, connStat); User::WaitForRequest(connStat); TESTL(KErrNone == connStat.Int()); // send packet 1 TRequestStatus stat; Logger().WriteFormat(_L("Attempting to create a packet to receive later")); _LIT8(sendDataOne, "First Send"); sock.Send(sendDataOne,0,stat); User::WaitForRequest(stat); TESTL(KErrNone == stat.Int()); // wait for packets to go through esock User::After(KOneSecond * 2); // gobble mBufs TInt nFree = 0; sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); while (nFree > 0) { ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); } Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret); // we are running in high priority and allocating in a loop. // so kernel may not be able to enlarge the pools. // wait for kernel to enlarge the pool // We have to come out from the loop as well. User::After(KOneSecond * 2); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); while (nFree > 0) { ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); } Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret); // Once again User::After(KOneSecond * 2); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); while (nFree > 0) { ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); } Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret); // Once again User::After(KOneSecond * 2); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); while (nFree > 0) { ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); } // Once again User::After(KOneSecond * 2); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol")); while (nFree > 0) { ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0); sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree); } // send packet 2 User::After(KOneSecond); TRequestStatus stat2; _LIT8(sendDataTwo, "Second Send"); Logger().WriteFormat(_L("Sending Data - Should never complete")); sock.Send(sendDataTwo,0,stat2); User::After(KOneSecond); Logger().WriteFormat(_L("Now cancel the Send")); sock.CancelSend(); User::WaitForRequest(stat2); TESTL(stat2 == KErrCancel); Logger().WriteFormat(_L("Receiving Data -- expected to pick up sendDataOne")); TBuf8<100> buf; TRequestStatus stat3; sock.Recv(buf, 0, stat3); User::After(KOneSecond); User::WaitForRequest(stat3); TESTL(buf.Compare(sendDataOne) == 0); // send packet 3 _LIT8(sendDataThree, "Third Send"); Logger().WriteFormat(_L("Sending Data ... again")); TRequestStatus stat4; sock.Send(sendDataThree,0,stat4); User::After(1000); // free memory Logger().WriteFormat(_L("Now free memory - should get send and receive completion")); Logger().WriteFormat(_L("Attempting to set KDummyOptionSetFreeMBufs Option in Protocol")); ret = sock.SetOpt(KDummyOptionSetFreeMBufs, 0, 0); Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret); TESTL(KErrNone == ret); Logger().WriteFormat(_L("Sending Data - Should now complete")); User::WaitForRequest(stat4); TESTL(stat4.Int() == KErrNone); // recieve data and compare contents to sent data Logger().WriteFormat(_L("Receiving Data")); sock.Recv(buf, 0, stat); User::WaitForRequest(stat); Logger().WriteFormat(_L("Recv has returned %d"), stat.Int()); TBuf<100> buf16; buf16.Copy(buf); if(buf.Compare(sendDataThree) == 0) { SetTestStepResult(EPass); } Logger().WriteFormat(_L("Data Recv'ed is '%S'"), &buf16); sock.Close(); ss.Close(); return TestStepResult(); }
TBool CTimesliceTestThread::Finished() { return (KRequestPending!=iExitStatus.Int()); }
TVerdict CEsockTest29::easyTestStepL() { // Open Sockets, one to manipulate mBufPool and one to send/revieve with tcp or udp TESTL( OpenSockets() == KErrNone ); // Bind Test Socket To local Address TInetAddr local; SetPort( local, KPort, KLocal ); iTestSocket.Bind( local ); // Connect Test Socket to LoopBack Address TInetAddr loopBack; SetPort( loopBack, KPort, KLoopback ); ConnectSocketL( iTestSocket, loopBack ); // Gobble all the Buf's in the MBuf Pool return the number of mBufs in Use TInt totalUsedBufs = iDummySocket.SetOpt( KDummyOptionSetGobbleMBufs, 0, 0 ); TInt bufsToBeFreed = 0; // Data to be used during socket Send GetIntFromConfig(KSection29, KBufSize, iBufSize); TBool keepSending = ETrue; TBuf8<4500> recvBuf; TBuf8<4500> sendData; sendData.Fill(TChar('z'), iBufSize ); TRequestStatus sendStatus; TRequestStatus recvStatus; const TInt KOneSecond = 1000000; for( TInt freeBufCounter = 0; freeBufCounter < totalUsedBufs && keepSending; freeBufCounter += bufsToBeFreed ) // OOB loop that will gradually release more MBufs { // release some mBufs and send iDummySocket.SetOpt( KDummyOptionSetFreeSomeMBufs, bufsToBeFreed , 0); iTestSocket.Send( sendData, 0, sendStatus ); // Wait for a second to allow time for server/protocol to send User::After( KOneSecond ); // Cancel the send and start to recv iTestSocket.CancelSend(); User::WaitForRequest(sendStatus); iTestSocket.Recv(recvBuf, 0, recvStatus); // Wait for a second to allow time for server/protocol to recieve User::After( KOneSecond ); iTestSocket.CancelRecv(); User::WaitForRequest( recvStatus ); if( freeBufCounter % 5 == 0 ) { INFO_PRINTF2( _L("freeBufs now >= %d "), freeBufCounter ); } if( recvBuf.Compare(sendData) == 0 ) // if we have recieved data then exit the loop { keepSending = EFalse; } bufsToBeFreed = 2; } // Now do a regular send for good measure to make sure everything is ok sendData.Fill(TChar('c'), iBufSize ); INFO_PRINTF1( _L("End of Loop, Now sending....") ); iTestSocket.Send( sendData, 0, sendStatus ); User::WaitForRequest( sendStatus ); INFO_PRINTF2( _L("Send Returned %d, now recieving...."), sendStatus.Int() ); iTestSocket.Recv( recvBuf, 0, recvStatus ); User::After( KOneSecond ); iTestSocket.CancelRecv(); User::WaitForRequest( recvStatus ); INFO_PRINTF2( _L("Recieve returned %d ") , recvStatus.Int() ); if( recvBuf.Compare(sendData) != 0 ) { return EFail; } return EPass; }
/** @SYMTestCaseID BA-CTSY-ALLS-MSL-0001 @SYMComponent telephony_ctsy @SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetALSLine @SYMTestPriority High @SYMTestActions Invokes RMobilePhone::SetALSLine @SYMTestExpectedResults Pass @SYMTestType CT */ void CCTsyAlternateLineServiceFU::TestSetALSLine0001L() { OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); RBuf8 data; CleanupClosePushL(data); TInt ret(-1); TRequestStatus requestStatus; //------------------------------------------------------------------------- // TEST B: failure on completion of pending request from LTSY->CTSY //------------------------------------------------------------------------- // create centRep to change repository CRepository* centRep = CRepository::NewL( KCRUidCtsyMEAlsLine ); CleanupStack::PushL(centRep); // setting environment (set KCtsyMEAlsSupported in repository to ETrue) ret = centRep->Set( KCtsyMEAlsSupported, ETrue ); ASSERT_EQUALS(KErrNone, ret); // test setting and execute RMobilePhone::TMobilePhoneALSLine alsLine(RMobilePhone::EAlternateLinePrimary); TMockLtsyData1< RMobilePhone::TMobilePhoneALSLine > alsLineData( alsLine ); alsLineData.SerialiseL(data); iMockLTSY.ExpectL(EMobilePhoneSetALSLine, data); iMockLTSY.CompleteL(EMobilePhoneSetALSLine, KErrGeneral); iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST C: Successful completion request of // RMobilePhone::SetALSLine when result is not cached. // Case CtsyMEAlsSupported ETrue //------------------------------------------------------------------------- iMockLTSY.ExpectL(EMobilePhoneSetALSLine, data); iMockLTSY.CompleteL(EMobilePhoneSetALSLine, KErrNone); iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST C: Successful completion request of // RMobilePhone::SetALSLine when result is not cached. // Case ÑtsyMEAlsSupported EFalse //------------------------------------------------------------------------- // setting environment (set KCtsyMEAlsSupported in repository to EFalse) ret = centRep->Set( KCtsyMEAlsSupported, EFalse ); ASSERT_EQUALS(KErrNone, ret); // test setting and execute alsLine = RMobilePhone::EAlternateLinePrimary; iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // check test results ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); ASSERT_EQUALS(alsLine, RMobilePhone::EAlternateLinePrimary); //check AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TESTs for coverage increasing with different values of alsLine //------------------------------------------------------------------------- // test execute alsLine = RMobilePhone::EAlternateLineAuxiliary; iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // check test results ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); ASSERT_EQUALS(alsLine, RMobilePhone::EAlternateLineAuxiliary); //check AssertMockLtsyStatusL(); // test execute alsLine = RMobilePhone::EAlternateLineUnknown; iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // check test results ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); ASSERT_EQUALS(alsLine, RMobilePhone::EAlternateLineUnknown); //check AssertMockLtsyStatusL(); // test execute alsLine = RMobilePhone::EAlternateLineNotAvailable; iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // check test results ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); ASSERT_EQUALS(alsLine, RMobilePhone::EAlternateLineNotAvailable); //check AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST E: Unsolicited completion of RMobilePhone::SetALSLine // from LTSY. //------------------------------------------------------------------------- iMockLTSY.NotifyTerminated(requestStatus); iMockLTSY.CompleteL(EMobilePhoneSetALSLine, KErrNone); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST A: failure to dispatch request to LTSY //------------------------------------------------------------------------- // setting environment (set KCtsyMEAlsSupported in repository to ETrue) ret = centRep->Set( KCtsyMEAlsSupported, ETrue ); ASSERT_EQUALS(KErrNone, ret); // test setting and execute data.Close(); alsLineData.SerialiseL(data); // serialise data here because alsLine variable is changed iMockLTSY.ExpectL(EMobilePhoneSetALSLine, data, KErrNotSupported); iPhone.SetALSLine(requestStatus, alsLine); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); AssertMockLtsyStatusL(); // Done ! // return repository KCtsyMEAlsSupported to EFalse (initial state) ret = centRep->Set( KCtsyMEAlsSupported, EFalse ); ASSERT_EQUALS(KErrNone, ret); AssertMockLtsyStatusL(); CleanupStack::PopAndDestroy(1); // iCentRep CleanupStack::PopAndDestroy(2, this); // data, this }
void CCSatSetUpCallFU::TestNotifySetUpCallPCmd0001cL() { OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); OpenSatL(); RSat::TSetUpCallRspV2 resp; RSat::TSetUpCallRspV2Pckg respPck(resp); RSat::TSetUpCallV6 setupCallData; const TUint8 KAddress = 0x91; //10010001 TData data; data.iCommandNumber = 1; data.iCommandQualifier = KSetUpCallIfNotCurrentlyBusy; data.iSourceDevice = KSim; data.iDestinationDevice = KNetwork; data.iAddress = KAddress; data.iCommandType = KSetUpCall; // // Expected Sequence 3.1A (SET UP CALL, display of basic icon during confirmation phase, // not selfexplanatory, successful) // data.iCallNumber.Append(0x10); data.iCallNumber.Append(0x32); data.iCallNumber.Append(0x04); data.iCallNumber.Append(0x21); data.iCallNumber.Append(0x43); data.iCallNumber.Append(0x65); data.iCallNumber.Append(0x1C); data.iCallNumber.Append(0x2C); const TUint8 KIconNotSelfExplanatory = 0x01; _LIT8(KAlphaIdentifier8_9, "Set up call Icon 3.1.1"); _LIT16(KAlphaIdentifier16_9, "Set up call Icon 3.1.1"); data.iIcon1.iIfUse = ETrue; data.iIcon1.iIdentifier = 0x01; data.iIcon1.iQualifier = KIconNotSelfExplanatory; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_9 ); DataCompareL(setupCallData, data.iCommandQualifier, KAlphaIdentifier16_9, RSat::EInternationalNumber, RSat::EIsdnNumberPlan); resp.iInfoType = RSat::KNoAdditionalInfo; resp.iAdditionalInfo.Zero(); resp.iGeneralResult = RSat::KSuccess; CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); // // Expected Sequence 3.2A (SET UP CALL, display of basic icon during confirmation phase, // selfexplanatory, successful) // const TUint8 KIconSelfExplanatory = 0x00; _LIT8(KAlphaIdentifier8_10, "Set up call Icon 3.2.1"); _LIT16(KAlphaIdentifier16_10, "Set up call Icon 3.2.1"); data.iIcon1.iQualifier = KIconSelfExplanatory; data.iIcon1.iIdentifier = 0x02; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_10 ); DataCompareL(setupCallData, data.iCommandQualifier, KAlphaIdentifier16_10, RSat::EInternationalNumber, RSat::EIsdnNumberPlan); resp.iGeneralResult = RSat::KSuccess; CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); // // Expected Sequence 3.3A (SET UP CALL, display of colour icon during confirmation phase, // not self-explanatory, successful) // _LIT8(KAlphaIdentifier8_11, "Set up call Icon 3.3.1"); _LIT16(KAlphaIdentifier16_11, "Set up call Icon 3.3.1"); data.iIcon1.iQualifier = KIconNotSelfExplanatory; data.iIcon1.iIdentifier = 0x02; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_11 ); DataCompareL(setupCallData, data.iCommandQualifier, KAlphaIdentifier16_11, RSat::EInternationalNumber, RSat::EIsdnNumberPlan); resp.iGeneralResult = RSat::KSuccess; CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); // // Expected Sequence 3.4A (display of self explanatory basic icon during set up call, // successful) // _LIT8(KAlphaIdentifier8_12_1, "Set up call Icon 3.4.1"); _LIT8(KAlphaIdentifier8_12_2, "Set up call Icon 3.4.2"); _LIT16(KAlphaIdentifier16_12, "Set up call Icon 3.4.1"); data.iIcon1.iQualifier = KIconSelfExplanatory; data.iIcon1.iIdentifier = 0x01; data.iIcon2.iIfUse = ETrue; data.iIcon2.iIdentifier = 0x01; data.iIcon2.iQualifier = KIconSelfExplanatory; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_12_1, KErrNone, KAlphaIdentifier8_12_2 ); DataCompareL(setupCallData, data.iCommandQualifier, KAlphaIdentifier16_12, RSat::EInternationalNumber, RSat::EIsdnNumberPlan); resp.iGeneralResult = RSat::KSuccess; CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); // // Expected Sequence 3.1B (SET UP CALL, display of basic icon during confirmation phase, // not selfexplanatory, requested icon could not be displayed) // // Parameters call for Expected Sequence 3.1A data.iIcon1.iQualifier = KIconNotSelfExplanatory; data.iIcon1.iIdentifier = 0x01; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_9 ); /* * The Expected Sequence 3.1B does not correspond to code. * CSatNotifySetUpCall::TerminalResponseL function returns KErrCorrupt code error * in case of "resp.iGeneralResult = RSat::KSuccessRequestedIconNotDisplayed". * But 3GPP TS 31.124 ( Section 27.22.4.13.3.4.2 ) document says that in case of * "resp.iGeneralResult = RSat::KSuccessRequestedIconNotDisplayed" * CSatNotifySetUpCall::TerminalResponseL function should return KErrNone. */ resp.iGeneralResult = RSat::KSuccessRequestedIconNotDisplayed; CCSatComponentTestBase::PrepareTerminalResponseMockDataL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, KNullDesC16, resp.iGeneralResult, KNullDesC8); TRequestStatus reqStatus; iSat.TerminalRsp(reqStatus, RSat::ESetUpCall, respPck); User::WaitForRequest(reqStatus); ASSERT_EQUALS(KErrNone, reqStatus.Int()); AssertMockLtsyStatusL(); // // Expected Sequence 3.2B (SET UP CALL, display of basic icon during confirmation phase, // selfexplanatory, requested icon could not be displayed) // data.iIcon1.iIdentifier = 0x02; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_10 ); CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); // // Expected Sequence 3.3B (SET UP CALL, display of colour icon during confirmation phase, // not self-explanatory, requested icon could not be displayed) // ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_11 ); CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); // // Expected Sequence 3.4B (SET UP CALL, display of self explanatory basic icon during // set up call, requested icon could not be displayed) // data.iIcon1.iQualifier = KIconSelfExplanatory; data.iIcon1.iIdentifier = 0x01; ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_12_1, KErrNone, KAlphaIdentifier8_12_2 ); CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult ); AssertMockLtsyStatusL(); CleanupStack::PopAndDestroy(1, this); // this }
/** @SYMTestCaseID BA-CTSY-ALLS-MSL-0004 @SYMComponent telephony_ctsy @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::SetALSLine @SYMTestPriority High @SYMTestActions Invokes multiple client requests to RMobilePhone::SetALSLine @SYMTestExpectedResults Pass @SYMTestType CT */ void CCTsyAlternateLineServiceFU::TestSetALSLine0004L() { OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); RBuf8 data; CleanupClosePushL(data); // Open second client RTelServer telServer2; TInt ret = telServer2.Connect(); ASSERT_EQUALS(KErrNone, ret); CleanupClosePushL(telServer2); RMobilePhone phone2; ret = phone2.Open(telServer2,KMmTsyPhoneName); ASSERT_EQUALS(KErrNone, ret); CleanupClosePushL(phone2); // create centRep to change repository CRepository* centRep = CRepository::NewL( KCRUidCtsyMEAlsLine ); CleanupStack::PushL(centRep); // setting environment (set KCtsyMEAlsSupported in repository to ETrue) ret = centRep->Set( KCtsyMEAlsSupported, ETrue ); ASSERT_EQUALS(KErrNone, ret); TRequestStatus requestStatus; TRequestStatus requestStatus2; //------------------------------------------------------------------------- // Test A: Test multiple clients requesting RMobilePhone::SetALSLine //------------------------------------------------------------------------- // setting and execute 1st request RMobilePhone::TMobilePhoneALSLine alsLine(RMobilePhone::EAlternateLinePrimary); TMockLtsyData1< RMobilePhone::TMobilePhoneALSLine > alsLineData( alsLine ); alsLineData.SerialiseL(data); iMockLTSY.ExpectL(EMobilePhoneSetALSLine, data); iMockLTSY.CompleteL(EMobilePhoneSetALSLine, KErrNone); iPhone.SetALSLine(requestStatus, alsLine); // setting and execute 2nd request RMobilePhone::TMobilePhoneALSLine alsLine2(RMobilePhone::EAlternateLineAuxiliary); phone2.SetALSLine(requestStatus2, alsLine2); // wait for completion and check results User::WaitForRequest(requestStatus2); ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // setting environment (set KCtsyMEAlsSupported in repository to ETrue) ret = centRep->Set( KCtsyMEAlsSupported, EFalse ); ASSERT_EQUALS(KErrNone, ret); // setting and execute the test for the case when // KCtsyMEAlsSupported in repository is set to ETrue alsLine = RMobilePhone::EAlternateLinePrimary; iPhone.SetALSLine(requestStatus, alsLine); alsLine2 = RMobilePhone::EAlternateLineAuxiliary; phone2.SetALSLine(requestStatus2, alsLine2); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); User::WaitForRequest(requestStatus2); ASSERT_EQUALS(KErrNone, requestStatus2.Int()); AssertMockLtsyStatusL(); //Done! CleanupStack::PopAndDestroy(1); // iCentRep CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this }
static void TestRUpsManagementL() /** Attempt to delete database */ { test.Start(_L("Testing RUpsManagement")); RThread thd; TRequestStatus rs; // Create filter TServiceId serviceId = {43}; CDecisionFilter *filter = CDecisionFilter::NewLC(); filter->SetClientSid(thd.SecureId(), EEqual); filter->SetServerSid(thd.SecureId(), EEqual); filter->SetServiceId(serviceId, EEqual); RUpsSubsession clientSubsession; TInt r = clientSubsession.Initialise(sTestSession, thd); test(r == KErrNone); test.Next(_L("Open management session")); RUpsManagement mngmnt; r = mngmnt.Connect(); test(r == KErrNone); User::LeaveIfError(r); test.Next(_L("View create - then delete DB")); mngmnt.CreateView(*filter, rs); test.Next(_L("Delete database")); TRAP(r, mngmnt.DeleteDatabaseL()); test(r == KErrNone); test.Next(_L("Now see what view create completed with....")); User::WaitForRequest(rs); test(rs.Int() == KErrAbort); test.Next(_L("Add entry to new database")); TUpsDecision dec = EUpsDecYes; clientSubsession.Authorise(EFalse, serviceId, _L("DB delete 1"), _L8("Opaque data"), dec, rs); User::WaitForRequest(rs); test(rs == KErrNone); test(dec == EUpsDecNo); dec = EUpsDecYes; clientSubsession.Authorise(EFalse, serviceId, _L("DB delete 2"), _L8("Opaque data"), dec, rs); User::WaitForRequest(rs); test(rs == KErrNone); test(dec == EUpsDecNo); test.Next(_L("View create - immediate cancel")); mngmnt.CreateView(*filter, rs); mngmnt.CancelAndCloseView(); User::WaitForRequest(rs); test(rs.Int() == KErrCancel); mngmnt.UpdateDecision(TUint32(-23), ETrue, rs); mngmnt.CancelUpdateDecision(); User::WaitForRequest(rs); test(rs.Int() == KErrCancel); mngmnt.UpdateDecision(TUint32(-23), ETrue, rs); User::WaitForRequest(rs); test(rs.Int() == KErrNotFound); test.Next(_L("View create - when busy")); TRequestStatus rs2; mngmnt.CreateView(*filter, rs); mngmnt.CreateView(*filter, rs2); User::WaitForRequest(rs2); test(rs2.Int() == KErrServerBusy); User::WaitForRequest(rs); test(rs.Int() == KErrNone); mngmnt.CancelAndCloseView(); test.Next(_L("View create - iterate through it")); mngmnt.CreateView(*filter, rs); User::WaitForRequest(rs); test(rs.Int() == KErrNone); CleanupStack::PopAndDestroy(filter); CDecisionRecord *record = 0; r = KErrNone; TInt recordCount = 0; while(r == KErrNone) { TRAP(r, record = mngmnt.NextMatchL()); if(record == 0) { break; } test(r == KErrNone); if(r == KErrNone) { ++recordCount; CleanupStack::PushL(record); CDecisionFilter *exactFilter = CDecisionFilter::NewLC(record->iClientSid, record->iEvaluatorId, record->iServiceId, record->iServerSid, record->iFingerprint, record->iClientEntity, record->iMajorPolicyVersion); mngmnt.UpdateDecision(record->iRecordId, ETrue, rs); User::WaitForRequest(rs); test(rs.Int() == KErrNone); TRAP(r, mngmnt.RemoveDecisionsL(*exactFilter)); test(r == KErrNone); CleanupStack::PopAndDestroy(exactFilter); CleanupStack::PopAndDestroy(record); } }; test(recordCount == 2); TRAP(r, record = mngmnt.NextMatchL()); test((r == KErrNone) && (record == 0)); mngmnt.CancelAndCloseView(); test.Next(_L("Close management session and clientSubsession")); mngmnt.Close(); clientSubsession.Close(); test.End(); }
/** @SYMTestCaseID BA-CTSY-ALLS-MGAL-0001 @SYMComponent telephony_ctsy @SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetALSLine @SYMTestPriority High @SYMTestActions Invokes RMobilePhone::GetALSLine @SYMTestExpectedResults Pass @SYMTestType CT */ void CCTsyAlternateLineServiceFU::TestGetALSLine0001L() { OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); RBuf8 data; CleanupClosePushL(data); TInt ret(KErrGeneral); TRequestStatus requestStatus; // dont change the tests order in order to preserve the environment state // at the beginig of every test //------------------------------------------------------------------------- // TEST E: Unsolicited completion of RMobilePhone::GetALSLine // from LTSY. //------------------------------------------------------------------------- // create centRep to change repository CRepository* centRep = CRepository::NewL( KCRUidCtsyMEAlsLine ); CleanupStack::PushL(centRep); // setting environment (set KCtsyMEAlsSupported in repository to EFalse) ret = centRep->Set( KCtsyMEAlsSupported, EFalse ); ASSERT_EQUALS(KErrNone, ret); // Unsolicited completion with new value EAlternateLineAuxiliary that is not yet cached in CTSY iMockLTSY.NotifyTerminated(requestStatus); RMobilePhone::TMobilePhoneALSLine alsLine(RMobilePhone::EAlternateLineAuxiliary); TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> alsLineData(alsLine); alsLineData.SerialiseL(data); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrNone, data); User::WaitForRequest(requestStatus); AssertMockLtsyStatusL(); ASSERT_EQUALS(KErrNone, requestStatus.Int()); // Unsolicited completion with the same value EAlternateLineAuxiliary that is cached in CTSY iMockLTSY.NotifyTerminated(requestStatus); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrNone, data); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST C: Successful completion request of // RMobilePhone::GetALSLine when result is not cached. //------------------------------------------------------------------------- // test setting and execute ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TESTs for coverage increasing with different values of alsLine and // of KCtsyMEAlsSupported from repository //------------------------------------------------------------------------- // setting environment (set alsLine to EAlternateLineUnknown) iMockLTSY.NotifyTerminated(requestStatus); alsLine = RMobilePhone::EAlternateLineUnknown; data.Close(); alsLineData.SerialiseL(data); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrNone, data); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // test setting and execute ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); AssertMockLtsyStatusL(); // setting environment (set KCtsyMEAlsSupported in repository to ETrue) ret = centRep->Set( KCtsyMEAlsSupported, ETrue ); ASSERT_EQUALS(KErrNone, ret); // test setting and execute alsLine = RMobilePhone::EAlternateLinePrimary; data.Close(); alsLineData.SerialiseL(data); iMockLTSY.ExpectL(EMobilePhoneGetALSLine, KErrNone); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrNone, data); ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); ASSERT_EQUALS(alsLine, RMobilePhone::EAlternateLinePrimary); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST D: RMobilePhone::GetALSLine again, this time CTSY // will get result from the cache. //------------------------------------------------------------------------- ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNone, ret); ASSERT_EQUALS(alsLine, RMobilePhone::EAlternateLinePrimary); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST B: failure on completion of pending request from LTSY->CTSY //------------------------------------------------------------------------- // change alsLine to EAlternateLineUnknown again iMockLTSY.NotifyTerminated(requestStatus); alsLine = RMobilePhone::EAlternateLineUnknown; data.Close(); alsLineData.SerialiseL(data); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrNone, data); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // test setting and execute iMockLTSY.ExpectL(EMobilePhoneGetALSLine, KErrNone); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrGeneral, data); ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrGeneral, ret); AssertMockLtsyStatusL(); //------------------------------------------------------------------------- // TEST A: failure to dispatch request to LTSY //------------------------------------------------------------------------- //change alsLine to EAlternateLineUnknown again iMockLTSY.NotifyTerminated(requestStatus); alsLine = RMobilePhone::EAlternateLineUnknown; data.Close(); alsLineData.SerialiseL(data); iMockLTSY.CompleteL(EMobilePhoneGetALSLine, KErrNone, data); User::WaitForRequest(requestStatus); ASSERT_EQUALS(KErrNone, requestStatus.Int()); AssertMockLtsyStatusL(); // test setting and execute iMockLTSY.ExpectL(EMobilePhoneGetALSLine, KErrNotSupported); ret = iPhone.GetALSLine(alsLine); ASSERT_EQUALS(KErrNotSupported, ret); AssertMockLtsyStatusL(); //Done! // return repository KCtsyMEAlsSupported to EFalse (initial state) ret = centRep->Set( KCtsyMEAlsSupported, EFalse ); ASSERT_EQUALS(KErrNone, ret); AssertMockLtsyStatusL(); CleanupStack::PopAndDestroy(1); // iCentRep CleanupStack::PopAndDestroy(2, this); // data, this }
/** @SYMTestCaseID SYSLIB-ECOM-CT-1808 @SYMTestCaseDesc Tests the uninstallation of an active plugin @SYMTestPriority High @SYMTestActions Creates a plugin implementation and then uninstalls the plugin's files from the C: Drive and waits for an ECOM notification completion, upon which it deletes the plugin. @SYMTestExpectedResults The test must not fail. @SYMREQ REQ0000 */ void TestUninstallL() { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1808 TestUninstallL ")); // Set up for heap leak checking and leaking thread handles __UHEAP_MARK; TInt startProcessHandleCount; TInt startThreadHandleCount; TInt endProcessHandleCount; TInt endThreadHandleCount; RThread thisThread; thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount); // Step 1: Setup the session to ECOM TInt err = KErrNone; REComSession& ecomSession = REComSession::OpenL(); CleanupClosePushL(ecomSession); // Step 2: Register for ECOM Server notification. TRequestStatus notifyStatus; ecomSession.NotifyOnChange(notifyStatus); TEST2(notifyStatus.Int(), KRequestPending); // Step 3. Create the plugin implementation we will uninstall TheTest.Printf(_L("CHeapTestInterface::NewL()\n")); CHeapTestInterface* implPtr = 0; TRAP(err, implPtr = CHeapTestInterface::NewL()); TEST2(err, KErrNone); // Step 4. Simulate the uninstall of the plugin files TheTest.Printf(_L("Deleting HTI plugin - attempt 1, wait 5s...\n")); //TRAP(err, EComTestUtils::FileManDeleteFileL(KHTI_PluginInstalledOnC)); TRAP(err, EComTestUtils::RLoaderDeleteFileL(KHTI_PluginInstalledOnC)); #if defined(__WINS__) || defined (__WINSCW__) TEST2(err, KErrAccessDenied); // DLL File locked under Windows emulator due to it being demand paged TheTest.Printf(_L("Error -21 (KErrAccessDenied) expected due to Windows keeping the DLL mapped in the emulator process adress space due to Windows demand paging/virtual memory system\n")); #elif defined(__EPOC32__) TEST2(err, KErrNone); // DLL File not locked on target hardware under SOS //#else Do no test at all as its an unexpected platform. #endif TRAP(err, EComTestUtils::FileManDeleteFileL(KHTIr_PluginInstalledOnC)); TEST2(err, KErrNone); // Step 5. Wait for ECOM Server notification to arrive, with precautionary hang timer. RTimer timer; CleanupClosePushL(timer); User::LeaveIfError(timer.CreateLocal()); TRequestStatus timerStatus; timer.After(timerStatus, KWaitDuration); TEST2(timerStatus.Int(), KRequestPending); TheTest.Printf(_L("Before calling WaitForAnyRequest(): Timer Status: %d; ECOM Notif Status: %d\n"), timerStatus.Int(), notifyStatus.Int()); TheTest.Printf(_L("Checking notification recieved for ECOM Server...\n")); User::WaitForRequest(timerStatus, notifyStatus); TEST2(timerStatus.Int(), KRequestPending); TEST2(notifyStatus.Int(), KErrNone); timer.Cancel(); // Step 6. Destroy the plugin TheTest.Printf(_L("DELETE implPtr\n")); delete implPtr; //CleanupStack::PopAndDestroy(&timer); TheTest.Printf(_L("Test over, cleanup...\n")); CleanupStack::PopAndDestroy(&timer); CleanupStack::PopAndDestroy(&ecomSession); REComSession::FinalClose(); // Check for open handles thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount); TEST(startThreadHandleCount == endThreadHandleCount); // Test Ends... __UHEAP_MARKEND; }
void CCTsyPrivacyFU::DoMultiNotifyPrivacyConfirmationL(const TDesC& aLineName) { //------------------------------------------------------------------------- // Test A: Test multiple clients requesting RMobileCall::NotifyPrivacyConfirmation //------------------------------------------------------------------------- // Open first client OpenEtelServerL(EUseExtendedError); CleanupStack::PushL(TCleanupItem(Cleanup,this)); OpenPhoneL(); RLine line1; TInt err = line1.Open(iPhone, aLineName); ASSERT_EQUALS(KErrNone, err) CleanupClosePushL(line1); RMobileCall mobileCall1; err = mobileCall1.OpenNewCall(line1); ASSERT_EQUALS(KErrNone, err) CleanupClosePushL(mobileCall1); // Open second client RTelServer telServer2; TInt ret = telServer2.Connect(); ASSERT_EQUALS(KErrNone, ret); CleanupClosePushL(telServer2); RMobilePhone phone2; ret = phone2.Open(telServer2,KMmTsyPhoneName); ASSERT_EQUALS(KErrNone, ret); CleanupClosePushL(phone2); RLine line2; err = line2.Open(phone2, aLineName); ASSERT_EQUALS(KErrNone, err) CleanupClosePushL(line2); RMobileCall mobileCall2; err = mobileCall2.OpenNewCall(line2); ASSERT_EQUALS(KErrNone, err) CleanupClosePushL(mobileCall2); // initialize variables with values other than passed to MockLTSY RMobilePhone::TMobilePhonePrivacy privacy1 = RMobilePhone::EPrivacyOn; RMobilePhone::TMobilePhonePrivacy privacy2 = RMobilePhone::EPrivacyOff; // request notifications TRequestStatus notifyStatus1; TRequestStatus notifyStatus2; mobileCall1.NotifyPrivacyConfirmation(notifyStatus1,privacy1); mobileCall2.NotifyPrivacyConfirmation(notifyStatus2,privacy2); // trigger EMobileCallNotifyPrivacyConfirmation completion via MockLTSY RMobilePhone::TMobilePhonePrivacy privacySetting = RMobilePhone::EPrivacyUnspecified; TMockLtsyCallData1<RMobilePhone::TMobilePhonePrivacy> privacySettingData(privacySetting); RBuf8 data; CleanupClosePushL(data); privacySettingData.SerialiseL(data); TRequestStatus mockLtsyStatus; iMockLTSY.NotifyTerminated(mockLtsyStatus); iMockLTSY.CompleteL(EMobileCallNotifyPrivacyConfirmation, KErrNone,data); User::WaitForRequest(mockLtsyStatus); CleanupStack::PopAndDestroy(1,&data); // data ASSERT_EQUALS(KErrNone,mockLtsyStatus.Int()); // wait for both notifications User::WaitForRequest(notifyStatus1); ASSERT_EQUALS(KErrNone,notifyStatus1.Int()); ASSERT_EQUALS(RMobilePhone::EPrivacyUnspecified, privacy1); User::WaitForRequest(notifyStatus2); ASSERT_EQUALS(KErrNone,notifyStatus2.Int()); ASSERT_EQUALS(RMobilePhone::EPrivacyUnspecified, privacy2); // cleanup second client CleanupStack::PopAndDestroy(4,&telServer2); // mobileCall2, line2, phone2, telServer2 AssertMockLtsyStatusL(); // cleanup first client CleanupStack::PopAndDestroy(3, this); // mobileCall1, line1, this }
TVerdict CPPPMinMaxMMU::doTestStepL() { const TInt KMaxMMU = 4000; const TInt KMinMMU = 1; TBuf8<KMaxMMU> *sendBuf = new(ELeave) TBuf8<KMaxMMU>(); CleanupStack::PushL(sendBuf); TBuf8<KMaxMMU> *recvBuf = new(ELeave) TBuf8<KMaxMMU>(); CleanupStack::PushL(recvBuf); TBuf8<KMaxMMU> *recvBuf2 = new(ELeave) TBuf8<KMaxMMU>(); CleanupStack::PushL(recvBuf2); //initialize COMM //CommInitL(EFalse); //Start Comms server // _LIT(KPhbkSyncCMI, "phbsync.cmi"); // (void)StartC32WithCMISuppressions(KPhbkSyncCMI); SetTestStepResult(EPass); INFO_PRINTF1(_L("Starting: Socket Server\n")); RSocketServ ss; // Start the socket server TEST(KErrNone == ss.Connect()); RSocket sock; TRequestStatus sta; INFO_PRINTF1(_L("Open a socket\n")); // Get the test address TInetAddr RemAddr(7); TPtrC testAddr; TEST(GetStringFromConfig(_L("AddressInfo"), _L("TestPPPIPAddr"), testAddr)); if(testAddr.Length()) { RemAddr.Input(testAddr); } else { INFO_PRINTF1(_L("Test FAILED\nMissing address information in config file: ")); return EFail; } // Open a socket TEST(KErrNone == sock.Open(ss, KAfInet, KSockStream, KProtocolInetTcp)); INFO_PRINTF1(_L("Connecting Socket to:")); TBuf<30> printAddr; RemAddr.Output(printAddr); INFO_PRINTF1(printAddr); // Connect a socket sock.Connect(RemAddr,sta); // Wait for Connect to complete User::WaitForRequest(sta); TEST(sta.Int() == 0); TInt iterEnd; GetIntFromConfig(_L("MMUInfo"), _L("TestPPPmaxMMU"), iterEnd); if (iterEnd > KMaxMMU) iterEnd = KMaxMMU; TInt iterStart; GetIntFromConfig(_L("MMUInfo"), _L("TestPPPminMMU"), iterStart); if (iterStart < KMinMMU) iterStart = KMinMMU; TInt i,j; TSockXfrLength recvLen; INFO_PRINTF1(_L("Send/Recv frames")); for(j=iterStart;j<=iterEnd;j++) { sendBuf->Zero(); for (i=0;i<j;i++) sendBuf->Append(Math::Random() & 0x7f); INFO_PRINTF2(_L("Sending Packet of Size: %d"),j); // Send data to echo port sock.Write(*sendBuf,sta); User::WaitForRequest(sta); TEST(sta.Int() == 0); i=0; recvBuf->Zero(); while(i<j) { // Receive data from echo port sock.RecvOneOrMore(*recvBuf2,0,sta,recvLen); User::WaitForRequest(sta); TEST(sta.Int() == 0); i += recvBuf2->Length(); recvBuf->Append(*recvBuf2); } TEST(KErrNone == recvBuf->Compare(*sendBuf)); INFO_PRINTF1(_L(" Received echoed Packet")); } sock.Shutdown(RSocket::EStopOutput,sta); User::WaitForRequest(sta); TEST(sta.Int() == 0); sock.Close(); ss.Close(); CleanupStack::PopAndDestroy(3); return TestStepResult(); }
// // Performes the test by connecting to MLFW // (and makes a number of Location requests if aFullTest is true // void DoTestL(TBool aFullTest, TInt aNumberOfRuns, TInt *aResult) { RPositionServer posServer; TInt errorCode = errorCode = posServer.Connect(); if (errorCode != KErrNone) { *aResult = KErrCouldNotConnect; return; } CleanupClosePushL(posServer); RPositioner positioner; // Full test means requesting position updates if (aFullTest) { TPositionInfo positionInfo = TPositionInfo(); const TInt32 KUidMultiPsy = 0x01010176; TUid uidMultiPsy; uidMultiPsy.iUid = KUidMultiPsy; errorCode = positioner.Open(posServer, uidMultiPsy); if (errorCode != KErrNone) { *aResult = errorCode; return; } CleanupClosePushL(positioner); _LIT(KService ,"Service"); errorCode = positioner.SetRequestor(CRequestor::ERequestorService, CRequestor::EFormatApplication, KService); if (errorCode != KErrNone) { *aResult = 1001; return; } TRequestStatus status; TLocality loca(TCoordinate(0,0,0),0); TPosition pos(loca, TTime(0)); for (TInt i = 0; i < aNumberOfRuns; i++) { positionInfo.SetPosition(pos); positioner.NotifyPositionUpdate(positionInfo, status); User::WaitForRequest(status); TInt err = status.Int(); if (err != KErrNone) { *aResult = err; } TPosition result; positionInfo.GetPosition(result); //sanity check if (result.Latitude() == pos.Latitude() || result.Longitude() == pos.Longitude() || result.Altitude() == pos.Altitude()) { //_LIT(KErrorPositon, "ERROR:: The postion was not updated"); errorCode = 1005; } } positioner.Close(); CleanupStack::PopAndDestroy(&positioner); } posServer.Close(); CleanupStack::PopAndDestroy(&posServer); }