/** Reads the file that is being written */ void TestReadingWhileWritingSameFile() { TInt r = 0; TF32TestTimer timer; timer.Start(); // Sync test TBuf<20> buf = _L("Big Write IV"); r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL); TEST(r == KErrNone); buf = _L("Read IV"); r = gSmall.Create(buf, ReadBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL); TEST(r == KErrNone); gBig.Resume(); gSmall.Resume(); CLIENTWAIT(); CLIENTWAIT(); CLOSE_AND_WAIT(gBig); CLOSE_AND_WAIT(gSmall); TTimeIntervalMicroSeconds timeTaken = gTestTimer.Time(); test.Printf(_L("\nSync write finished %d ms before the read ended\n"),TF32TestTimer::TimeInMilliSeconds(timeTaken)); }
/** Starts two concurrent client sessions in different directories */ LOCAL_C void DoTest2(TThreadFunction aFunction) { gKillMe = EFalse; TBuf<20> buf = _L("Speedy"); buf.AppendNum(ThreadCount++); gT1 = ThreadCount; TInt r = gSpeedy.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL); FailIfError(r); buf = _L("Speedy"); buf.AppendNum(ThreadCount++); gT2 = ThreadCount; r = gSpeedyII.Create(buf, DeleteEntryAccess2, KDefaultStackSize, KHeapSize, KHeapSize, NULL); FailIfError(r); gSpeedy.SetPriority(EPriorityLess); gSpeedyII.SetPriority(EPriorityLess); gSpeedy.Resume(); gSpeedyII.Resume(); client.Wait(); client.Wait(); }
static TInt StartServer() // // Start the server process or thread // { const TUidType serverUid(KNullUid,KNullUid,KServerUid3); #ifdef __CDLSERVER_NO_PROCESSES__ // // In EKA1 WINS the server is a DLL, the exported entrypoint returns a TInt // which represents the real entry-point for the server thread // RLibrary lib; TInt r=lib.Load(KCdlServerDllImg,serverUid); if (r!=KErrNone) return r; TLibraryFunction ordinal1=lib.Lookup(1); TThreadFunction serverFunc=reinterpret_cast<TThreadFunction>(ordinal1()); // // To deal with the unique thread (+semaphore!) naming in EPOC, and that we may // be trying to restart a server that has just exited we attempt to create a // unique thread name for the server. // This uses Math::Random() to generate a 32-bit random number for the name // TName name(KCdlServerName); name.AppendNum(Math::Random(),EHex); RThread server; r=server.Create(name,serverFunc, KCdlServerStackSize, NULL,&lib,NULL, KCdlServerInitHeapSize,KCdlServerMaxHeapSize,EOwnerProcess); lib.Close(); // if successful, server thread has handle to library now #else // // EPOC and EKA2 is easy, we just create a new server process. Simultaneous launching // of two such processes should be detected when the second one attempts to // create the server object, failing with KErrAlreadyExists. // RProcess server; TInt r=server.Create(KCdlServerExeImg,KNullDesC,serverUid); #endif if (r!=KErrNone) return r; TRequestStatus stat; server.Rendezvous(stat); if (stat!=KRequestPending) server.Kill(0); // abort startup else server.Resume(); // logon OK - start the server User::WaitForRequest(stat); // wait for start or death // we can't use the 'exit reason' if the server panicked as this // is the panic 'reason' and may be '0' which cannot be distinguished // from KErrNone r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); server.Close(); return r; }
/** Writes a small file while writing a big one */ void TestWritingWhileWriting() { TInt r = 0; // Sync test TBuf<20> buf = _L("Big Write II"); r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL); TEST(r == KErrNone); buf = _L("Small Write II"); r = gSmall.Create(buf, WriteSmallFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL); TEST(r==KErrNone); gBig.Resume(); gSmall.Resume(); CLIENTWAIT(); CLIENTWAIT(); gBig.Close(); gSmall.Close(); TTimeIntervalMicroSeconds timeTaken = gTestTimer.Time(); test.Printf(_L("\nSync write done %d ms before the big write ended\n"), gTestTimer.TimeInMilliSeconds()); #if !defined(__WINS__) // If this condition fails, it means that writing the sync file while // fairscheduling a small sync write takes too long test(timeTaken > 0); #endif // Async test TRequestStatus status[KWaitRequestsTableSize]; TRequestStatus status2[1]; RFile bigFile, smallFile; WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize, KBigBlockSize, status); WriteFileAsync(TheFs,smallFile, gSmallFile,gSmallFileSize,KBlockSize,status2); WaitForAll(status2,gSmallFileSize, KBlockSize); TF32TestTimer timer; timer.Start(); WaitForAll(status, gBigFileSize, KBigBlockSize); timer.Stop(); timeTaken = timer.Time(); test.Printf(_L("\nAsync write done %d ms before the big write ended\n"),timer.TimeInMilliSeconds()); #if !defined(__WINS__) if (!Is_HVFS(TheFs, gDrive)) { // If this condition fails, it means that writing the async file while fairscheduling a small async write takes too long test.Printf(_L("gTotalTimeAsync[0] = %d , gTotalTimeAsync[1] = %d\n"),gTotalTimeAsync[0],gTotalTimeAsync[1] ); test(timeTaken > 0); } #endif bigFile.Close(); smallFile.Close(); }
// ----------------------------------------------------------------------------- // MceServerStarter::CreateServerProcess // ----------------------------------------------------------------------------- // TInt MceServerStarter::CreateServerProcess (RSemaphore& aSemaphore) { const TUidType serverUid (KNullUid, KNullUid, KServerUid3); #if ((defined (__WINS__) || defined(__WINSCW__)) && !defined (EKA2)) RLibrary lib; RETURN_IF_ERROR (lib.Load(KMceServerFilename,serverUid)) // Get the WinsMain function TLibraryFunction functionWinsMain = lib.Lookup (1); // Call it and cast the result to a thread function TThreadFunction serverThreadFunction = reinterpret_cast<TThreadFunction> (functionWinsMain()); TName threadName (KSipServerName); // Append a random number to make it unique threadName.AppendNum (Math::Random(), EHex); RThread server; TInt err = server.Create (threadName, serverThreadFunction, // thread's main function KDefaultStackSize, NULL, &lib, NULL, KServerMinHeapSize, KServerMaxHeapSize, EOwnerProcess ); lib.Close (); // if successful, server thread has handle to library now RETURN_IF_ERROR (err) server.SetPriority (EPriorityMore); #else // HW build RProcess server; RETURN_IF_ERROR (server.Create( KMceServerName, KNullDesC, serverUid ) ) #endif server.Resume (); aSemaphore.Wait(); TInt exitReason = server.ExitReason(); server.Close (); return exitReason; }
static void TestRUpsSubsessionDeathL() { RThread thd; TRequestStatus thdStatus; User::LeaveIfError(thd.Create(_L("MyThread"), ThreadFunction, 4096, 4096, 4096, 0, EOwnerThread)); // thd.SetHandle(666); thd.Rendezvous(thdStatus); thd.Kill(KErrAbort); User::WaitForRequest(thdStatus); test.Start(_L("Testing RUpsSubsession")); RUpsSubsession clientSubsession; TInt r = clientSubsession.Initialise(sTestSession, thd); test(r == KErrNone); test.Next(_L("Query with dead thread id")); TServiceId serviceId = {43}; TUpsDecision dec = EUpsDecYes; TRequestStatus rs; thd.Close(); clientSubsession.Authorise(EFalse, serviceId, _L("req1"), dec, rs); User::WaitForRequest(rs); test(rs == KErrNone); test(dec == EUpsDecNo); clientSubsession.Close(); test.End(); }
TInt RConsoleProxy::DoConnect(TServerParams* aParams, const TDesC& aThreadNameBase, TInt aStackSize, TInt aHeapMinSize, TInt aHeapMaxSize, RServer2& aServer, RThread& aServerThread) { TName threadName; RThread server; TInt threadId = 0; _LIT(KThreadIdFmt, "%08x"); TInt err; do { threadName = aThreadNameBase.Left(threadName.MaxLength()-8); threadName.AppendFormat(KThreadIdFmt, threadId); err = server.Create(threadName, &ServerThreadFunction, aStackSize, aHeapMinSize, aHeapMaxSize, aParams); ++threadId; } while (err==KErrAlreadyExists); if (err!=KErrNone) return err; TRequestStatus rendezvous; server.Rendezvous(rendezvous); if (rendezvous == KRequestPending) { server.Resume(); } User::WaitForRequest(rendezvous); err = rendezvous.Int(); if (server.ExitType() != EExitPending && err >= 0) err = KErrDied; if (err==KErrNone) { err = Connect(aParams->iServer); } aServer = aParams->iServer; aServerThread = server; return err; }
// ---------------------------------------------------------------------------- // CSIPClientResolver::CreateWorkerThreadL // ---------------------------------------------------------------------------- // void CSIPClientResolver::CreateWorkerThreadL() { TName threadName(KWorkerThreadName); // Append a random number to make the name unique const TInt KThreadIdWidth = 10; threadName.AppendNumFixedWidthUC(Math::Random(), EHex, KThreadIdWidth); RThread thread; TInt err = thread.Create(threadName, WorkerThreadFunction, KDefaultStackSize, NULL, // Use the same heap as the main thread this); User::LeaveIfError(err); TRequestStatus status; thread.Logon(status); thread.Resume(); User::WaitForRequest(status); TExitType exitType = thread.ExitType(); thread.Close(); if (exitType == EExitPanic) { User::Leave(KErrGeneral); } User::LeaveIfError(status.Int()); }
LOCAL_C void RunTest(TInt aSize) { const TInt KTestRunUs = KTestRunSeconds * 1000000; RThread t; TInt r=t.Create(KNullDesC,TestThread,0x1000,NULL,(TAny*)aSize); test(r==KErrNone); t.SetPriority(EPriorityLess); TRequestStatus s; t.Logon(s); t.Resume(); ServerSem.Wait(); test(Server.Handle() != KNullHandle); RMySession sess; TRequestStatus stat; test(sess.Connect(Server,stat) == KErrNone); User::WaitForRequest(stat); // connected Count=0; TPtr8 des((TUint8*)Dest, 0, aSize); sess.Test(des); User::After(KTestRunUs); t.Kill(0); User::WaitForRequest(s); sess.Close(); Server.Close(); CLOSE_AND_WAIT(t); TInt us=10*KTestRunUs/Count; test.Printf(_L("%5d byte writes: %8d/%ds %4d.%01dus\n"),aSize,Count,KTestRunSeconds,us/10,us%10); }
/** @SYMTestCaseID GRAPHICS-FBSERV-0593 @SYMTestCaseDesc Tests the cleaning when a thead is panicing. @SYMTestActions Creates a bitmap. Checks the resource count. Creates a thread with high priority. Unlocks the heap and locks it back again. Disables just-in-time debugging. Waits for he thead to complete its execution. The created thread creates its own cleanup stack and connects to a FbsSession. It creates three bitmaps and duplicates one of them to the other. A FbsTypefaceStore object is created on the heap an GetNearestFontToDesignHeightInPixel is called on it. Disconnect from the FbsSession. The thread is paniced and terminated. The function that created the thread now continues its execution by checking the exit reason for the thread. Closes the thead. Enables just-in-time again. Locks the heap and unlocks it again. Checks the resource count. Deletes scan line buffer. The heap is checked for memory leaks. @SYMTestExpectedResults Test should pass */ void CTClean::DeadThread() { __UHEAP_MARK; CFbsBitmapEx bmp; TInt ret=bmp.Create(TSize(100,100),EGray16); TEST(ret==KErrNone); TInt rc=iFbs->ResourceCount(); TEST(rc==1); RThread thrd; TRequestStatus stat; thrd.Create(_L("ctt"),CleanupTestThread,KDefaultStackSize,0x8000,0x8000,this); thrd.SetPriority(EPriorityMuchMore); thrd.Logon(stat); User::SetJustInTime(EFalse); bmp.LockHeap(); bmp.UnlockHeap(); thrd.Resume(); User::WaitForRequest(stat); ret = thrd.ExitReason(); thrd.Close(); User::SetJustInTime(ETrue); TEST(ret == KErrNone); INFO_PRINTF1(_L("About to lock heap\r\n")); bmp.LockHeap(); bmp.UnlockHeap(); rc=iFbs->ResourceCount(); TEST(rc==1); DeleteScanLineBuffer(); __UHEAP_MARKEND; }
/** @SYMTestCaseID PDS-EFM-CT-4058 @SYMTestCaseDesc Querying and modifying a feature during restore operation. Verify that a response is returned from the server during restore. @SYMTestPriority High @SYMTestActions Start simulating restore operation Create a thread that will: Modify a feature and verify that a response (KErrServerBusy) is received Query a feature and verify that a response is received (doesn't matter what the result is) The thread should finished in less than 2 seconds. Otherwise the test fail. @SYMTestExpectedResults Test must not fail @SYMREQ */ void TestRestoreResponseL() { _LIT(KThreadName, "RstTh"); featMgrIsResponsive = EFalse; CFeatMgrBURSim* simulate = CFeatMgrBURSim::NewLC(); RThread testThread; TRequestStatus testStatus; CleanupClosePushL( testThread ); //Needs to ensure server is started before simulating backup operation RFeatureControl rfc; TTEST2( rfc.Connect(), KErrNone ); //This will start the server if not already started rfc.Close(); simulate->Simulate_CheckRegFileL(); // Simulate a restore RDebug::Print(_L("Simulating Restore of FeatMgr\r\n")); simulate->Simulate_StartRestoreL(); TEST2( testThread.Create(KThreadName, &TestThreadL, 0x2000, 0x1000, 0x10000, NULL, EOwnerProcess), KErrNone ); testThread.Logon(testStatus); TEST2( testStatus.Int(), KRequestPending ); testThread.Resume(); // Wait for 1.5 second for the query thread to finish. RDebug::Print(_L("+++:MainThread: Wait for query and modification completion...\r\n")); MainThreadCrS.Wait(threadTimeout); // If query is responsive within the 1.5 second frame the following check should pass. TEST (featMgrIsResponsive); simulate->Simulate_EndRestoreL(); CleanupStack::PopAndDestroy(&testThread); CleanupStack::PopAndDestroy(simulate); }
void TestCommitDecommit(RPageMove& pagemove, RChunk& aChunk) { test.Printf(_L("Attempt to move a page while it is being committed and decommited\n")); RThread thread; TRequestStatus s; test_KErrNone(thread.Create(_L("CommitDecommit"), &CommitDecommit, KDefaultStackSize, NULL, (TAny*)&aChunk)); thread.Logon(s); thread.SetPriority(EPriorityMore); thread.Resume(); TUint8* firstpage=(TUint8*)_ALIGN_DOWN((TLinAddr)aChunk.Base(), PageSize); for (TInt i=0; i < Repitions; i++) { TInt r = pagemove.TryMovingUserPage(firstpage, ETrue); // Allow all valid return codes as we are only testing that this doesn't // crash the kernel and the page could be commited, paged out or decommited // at any one time. test_Value(r, r <= KErrNone); } thread.Kill(KErrNone); User::WaitForRequest(s); test_Equal(EExitKill,thread.ExitType()); test_KErrNone(thread.ExitReason()); thread.Close(); }
/** * Auxiliary function for TestCaseID TAppLangSTARTER_doTestStepL * * This method creates the server thread by invoking RThread::Create() and calls * CMessageServServer::ThreadFunction() to start the Message Server. * */ TInt CTestApplicationLanguageStep::StartThread() { TInt res=KErrNone; // create server - if one of this name does not already exist TFindServer findCountServer(KMessageServerName); TFullName name; if (findCountServer.Next(name)!=KErrNone) // we don't exist already { RThread thread; semaphore.CreateLocal(0); // create a semaphore so we know when thread finished res=thread.Create(KMessageServerName, // create new server thread CMessageServServer::ThreadFunction, // thread's main function KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, this // passed as TAny* argument to thread function ); if (res==KErrNone) // thread created ok - now start it going { thread.SetPriority(EPriorityNormal); thread.Resume(); // start it going semaphore.Wait(); // wait until it's initialized thread.Close(); // we're no longer interested in the other thread } else // thread not created ok { thread.Close(); // therefore we've no further interest in it } semaphore.Close(); } return res; }
TTestObject::~TTestObject() { RDebug::Printf("t_destruct_slave destructor called\n"); if (iTestType == ETestRecursive) { // Start child thread passing this thread's id MainThreadId = RThread().Id(); RThread childThread; test_KErrNone(childThread.Create(_L("ChildThread"), ChildThread, 4096, NULL, (TAny*)iTestType)); TRequestStatus status; childThread.Rendezvous(status); childThread.Resume(); // Wait for child to open handle on this thread User::WaitForRequest(status); test_KErrNone(status.Int()); childThread.Close(); // Set this thread non-critical User::SetCritical(User::ENotCritical); } else if (iTestType == ETestDestructorExits) { User::Exit(iTestType); } RMsgQueue<TMessage> messageQueue; TInt r = messageQueue.OpenGlobal(KMessageQueueName); if (r != KErrNone) Panic(r); messageQueue.Send(EMessageDestruct); if (r != KErrNone) Panic(r); }
// EKA2 much simpler // Just an E32Main and a MainL() LOCAL_C void MainL() /** * Much simpler, uses the new Rendezvous() call to sync with the client */ { // Leave the hooks in for platform security #if (defined __DATA_CAGING__) RProcess().DataCaging(RProcess::EDataCagingOn); RProcess().SecureApi(RProcess::ESecureApiOn); #endif CActiveScheduler* sched=NULL; sched=new(ELeave) CActiveScheduler; CActiveScheduler::Install(sched); CMMFAudioServer* server = NULL; TRAPD(err,server = CMMFAudioServer::NewL()); // Start BT audio server in its own thread here... // Assume that the server's not been started already // RThread btServerThread; TThreadFunction btServerThreadFunc = CA2dpBTHeadsetAudioIfServer::StartThread; TName btServerName(KA2DPAudioServerName); err = btServerThread.Create(btServerName, btServerThreadFunc, KBTAudioServerStackSize, KBTAudioServerInitHeapSize, KBTAudioServerMaxHeapSize, NULL, EOwnerProcess); // NULL => not passing any params to thread if(!err) { // Synchronise with the server TRequestStatus reqStatus; btServerThread.Rendezvous(reqStatus); if (reqStatus != KRequestPending) { btServerThread.Kill(0); } else { // Start the thread btServerThread.Resume(); // Server will call the reciprocal static synchronise call } User::WaitForRequest(reqStatus); // wait for start or death } if(!err) { // Sync with the client and enter the active scheduler RProcess::Rendezvous(KErrNone); sched->Start(); } btServerThread.Close(); delete server; delete sched; }
void TestPanic(TPanicFunc aFunc, TInt aExpectedReason) /** Creates a new thread, runs the supplied function in its context, and confirms that it is panicked with category KKmsClientPanicCat and the supplied reason. @param aFunc Function to call in context of new thread. @param aExpectedReason The newly-created thread is expected to be panicked with this reason. */ { test.Printf(_L("TestPanic: KmsLdd %d\n"), aExpectedReason); RThread thd; TInt r = thd.Create( _L("KmsTestTestPanic"), TestPanicEntrypoint, KDefaultStackSize, KMinHeapSize, KMinHeapSize, (TAny*) aFunc); test(r == KErrNone); TRequestStatus rs; thd.Rendezvous(rs); test(rs == KRequestPending); TInt jit = User::JustInTime(); User::SetJustInTime(EFalse); thd.Resume(); User::WaitForRequest(rs); User::SetJustInTime(jit); ConfirmPanicReason(thd, aExpectedReason); thd.Close(); }
// main loop // GLDEF_C TInt E32Main() { __UHEAP_MARK; CTrapCleanup* theCleanup = CTrapCleanup::New(); // Install exception handler // Create a new thread for running tests in RThread testThread; TInt err = testThread.Create(KTestThreadName, TestEntryPoint, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, NULL); if(err == KErrNone) { testThread.Resume(); } else { return err; } // Kick off test thread and wait for it to exit TRequestStatus tStat; testThread.Logon(tStat); User::WaitForRequest(tStat); // Log if paniced if(testThread.ExitType() == EExitPanic) { TRAP_IGNORE(LogOnPanicL(testThread)); } testThread.Close(); delete theCleanup; __UHEAP_MARKEND; return KErrNone; }
void TestServerApi(TInt aFunctionNumber, TInt aTestType,TInt aArgCount, TExitDetails& aExitDetails) { TTestInfo testInfo; testInfo.iFunction = aFunctionNumber; testInfo.iType = aTestType; testInfo.iArgCount = aArgCount; RThread thread; _LIT(KThreadName,"FuzzerThread" ); TInt err = thread.Create(KThreadName,&FuzzServerL, KDefaultStackSize, NULL,&testInfo); TEST2(err, KErrNone); TRequestStatus threadStat; thread.Logon(threadStat); TBool jit = User::JustInTime(); User::SetJustInTime(EFalse); thread.Resume(); User::WaitForRequest(threadStat); User::SetJustInTime(jit); aExitDetails.iCategory = thread.ExitCategory(); aExitDetails.iReason = thread.ExitReason(); aExitDetails.iExitType = thread.ExitType(); thread.Close(); }
/* * Creates a Thread that modifies its code in a tight loop while the main * thread moves the functions page around */ LOCAL_C TInt TestCodeModificationAsync(RPageMove& pagemove) { TInt ret; RThread CodeThread; TRequestStatus s; /* Create the Thread to modify the code segment */ test_KErrNone(CodeThread.Create(_L("TestCodeAsync"), TestCodeAsync, KDefaultStackSize, NULL, NULL)); CodeThread.Logon(s); CodeThread.SetPriority(EPriorityMore); CodeThread.Resume(); TestCodeSetupDrive(CodeThread); /* Loop trying to move the code page while the thread (CodeThread) modifies it */ for (TInt i=0; i<Repitions; i++) { test_KErrNone(pagemove.TryMovingUserPage((TAny*)TestCodeModFunc)); } CodeThread.Kill(KErrNone); User::WaitForRequest(s); test_Equal(EExitKill, CodeThread.ExitType()); test_KErrNone(CodeThread.ExitReason()); CodeThread.Close(); ret = TestCodeModFunc(); test(ret == 1 || ret == 2); return KErrNone; }
void TestServerPanic() { TRequestStatus status; test_KErrNone(TheSemaphore.CreateLocal(0)); RDebug::Printf("Main: start server"); RThread serverThread; test_KErrNone(serverThread.Create(_L("server"), ServerThread, 4096, NULL, NULL)); serverThread.Rendezvous(status); serverThread.Resume(); User::WaitForRequest(status); test_KErrNone(status.Int()); RDebug::Printf("Main: start client"); RProcess clientProcess; test_KErrNone(clientProcess.Create(KMyName, _L("client"))); clientProcess.Resume(); clientProcess.Logon(status); User::WaitForRequest(status); test_KErrNone(clientProcess.ExitReason()); test_Equal(EExitKill, clientProcess.ExitType()); RDebug::Printf("Main: kick server"); TheSemaphore.Signal(); RDebug::Printf("Main: wait for server to exit"); serverThread.Logon(status); User::WaitForRequest(status); test_KErrNone(serverThread.ExitReason()); test_Equal(EExitKill, serverThread.ExitType()); User::After(1); RDebug::Printf("Main: exit"); }
/** Test framework to check for panic scenarios It requires to create a separate thread so we can check the panic category and code. */ TInt StartSwpInvalidListInThreadL(CSsmValidSwpListTest* aSsmValidSwpListTest) { RThread thread; // Give each thread a unique name to avoid KErrAlreadyExists error on thread creation _LIT(KThreadNamePrefix, "SsmTestThread"); RBuf threadName; CleanupClosePushL(threadName); threadName.CreateL(KThreadNamePrefix().Length() + 6); // 6 digit thread number threadName = KThreadNamePrefix; threadName.AppendNumFixedWidth(aSsmValidSwpListTest->Function(), EDecimal, 6); const TInt KMinHeapSize = 0xc800; // 50k - NOTE just an arbitrary value, please feel free to change it const TInt KMaxHeapSize = 0x19000; // 100k - NOTE just an arbitrary value, please feel free to change it User::LeaveIfError(thread.Create(threadName, ThreadStartSwpInvalidListFn, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, aSsmValidSwpListTest)); CleanupStack::PopAndDestroy(&threadName); TRequestStatus status; thread.Logon(status); TBool jit = User::JustInTime(); User::SetJustInTime(EFalse); thread.Resume(); User::WaitForRequest(status); // always expecting a state transition engine panic TExitCategoryName category = thread.ExitCategory(); if (category.Compare(KPanicSysStateMgr) != 0) { User::Leave(KTestInvalidPanicCategory); } const TInt exitReason = thread.ExitReason(); thread.Close(); User::SetJustInTime(jit); // return the exit reason for the caller to verify the expected panic value return exitReason; }
LOCAL_D void TestSelfSuspend(TOwnerType anOwnerType) // // Test running a thread that suspends itself. This activity has // deadlocked the Emulator in the past // { RThread suspendThread; TInt r; TRequestStatus s; TInt jit=User::JustInTime(); test.Start(_L("Test running a thread which suspends itself")); test.Next(_L("Create the thread")); r=suspendThread.Create(KNullDesC,SuspendThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)NULL,anOwnerType); test(r==KErrNone); suspendThread.Logon(s); suspendThread.Resume(); test.Next(_L("Wait a second")); User::After(1000000); User::SetJustInTime(EFalse); suspendThread.Panic(_L("FEDCBA9876543210fedcba"),999); User::WaitForRequest(s); User::SetJustInTime(jit); test(suspendThread.ExitType()==EExitPanic); test(suspendThread.ExitReason()==999); test(suspendThread.ExitCategory()==_L("FEDCBA9876543210")); CLOSE_AND_WAIT(suspendThread); test.End(); }
TInt CTSISHelperStepBase::startSisHelper(Swi::TSisHelperStartParams& aParams) { // To deal with the unique thread (+semaphore!) naming in Symbian OS, and // that we may be trying to restart a server that has just exited we // attempt to create a unique thread name for the server TName name(Swi::KSisHelperServerName); name.AppendNum(Math::Random(), EHex); RThread server; const TInt KSisHelperServerStackSize=0x2000; const TInt KSisHelperServerInitHeapSize=0x1000; const TInt KSisHelperServerMaxHeapSize=0x1000000; TInt err=server.Create(name, sisHelperThreadFunction, KSisHelperServerStackSize, KSisHelperServerInitHeapSize, KSisHelperServerMaxHeapSize, static_cast<TAny*>(&aParams), EOwnerProcess); if (err!=KErrNone) return err; // The following code is the same whether the server runs in a new thread // or process TRequestStatus stat; server.Rendezvous(stat); if (stat!=KRequestPending) server.Kill(0); // abort startup else server.Resume(); // logon OK, start the server User::WaitForRequest(stat); // wait for start or death // we can't use the 'exit reason' if the server panicked as this is the // panic 'reason' and may be 0 which cannot be distinguished from KErrNone err=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); server.Close(); return err; }
TInt CTimesliceTestThread::Construct(TUint32 aId, TInt aCpu, TInt aSlice, CircBuf* aBuf) { iId = aId; iCpu = aCpu; iSlice = aSlice; iBuf = aBuf; TInt r = HAL::Get(HAL::EFastCounterFrequency, (TInt&)iFreq); if (r!=KErrNone) return r; iThresh = iFreq / 3000; if (iThresh < 10) iThresh = 10; iThresh2 = iFreq; TBuf<16> name = _L("TSThrd"); name.AppendNum(iId); r = iThread.Create(name, &ThreadFunc, 0x1000, NULL, this); if (r!=KErrNone) return r; iThread.Logon(iExitStatus); if (iExitStatus != KRequestPending) { iThread.Kill(0); iThread.Close(); iThread.SetHandle(0); return iExitStatus.Int(); } return KErrNone; }
TExitDetails LaunchTestThread(const TDesC& aThreadName, TestFunction aFunction) { RThread thread; thread.Create(aThreadName, &TestFunctionLauncher, KDefaultStackSize, NULL, (TAny*)aFunction); TRequestStatus threadStat; thread.Logon(threadStat); TBool jit = User::JustInTime(); User::SetJustInTime(EFalse); thread.Resume(); User::WaitForRequest(threadStat); User::SetJustInTime(jit); TExitDetails exitDetails; exitDetails.iCategory = thread.ExitCategory(); exitDetails.iReason = thread.ExitReason(); exitDetails.iExitType = thread.ExitType(); thread.Close(); return exitDetails; }
/** Intended Usage : Capture the PANIC that occurs in the thread. @param : aName The name to be assigned to this thread. @param : aFunction The function which causes the panic. */ LOCAL_C void ThreadPanicTest(const TDesC& aName,TThreadFunction aFunction) { TheTest.Next(aName); TRequestStatus threadStatus; RThread thread; TBool jit; jit=User::JustInTime(); User::SetJustInTime(EFalse); for (TInt i = EIterFunctionDriveUnit; i <= EIterFunctionIsRemovable; i++) { TIteratorFunctionToTest func = static_cast<TIteratorFunctionToTest>(i); TInt err=thread.Create(aName,aFunction,KDefaultStackSize,KMinHeapSize,KMinHeapSize, &func); TESTL(err==KErrNone); thread.Logon(threadStatus); thread.Resume(); User::WaitForRequest(threadStatus); //Now check why the thread Exit TExitType exitType = thread.ExitType(); TInt exitReason = thread.ExitReason(); TheTest.Printf(_L("PanicTest: exitType %d, reason %d\n"), exitType, exitReason); TESTL(exitType == EExitPanic); TESTL(exitReason == KPanicIndexOutOfBound); thread.Close(); } User::SetJustInTime(jit); }
TInt64 runTest(TThreadFunction aFunction,const TDesC& aTitle) { RThread thread; TInt r=thread.Create(aTitle,aFunction,KDefaultStackSize,KHeapSize,KHeapSize,NULL); if(r!=KErrNone) { test.Printf(_L("Failed to create thread with error %d\n"),r); return(r); } thread.Resume(); User::After(1000000); count=0; User::After(KAverageOverInSeconds*1000000); TInt64 result=count; barrier = a; if (!barrier) barrier = c; barrier = b; if (!barrier) barrier = a; barrier = c; if (!barrier) barrier = b; thread.Kill(0); thread.Close(); result*=KNumberOfCalculationsPerLoop; result/=KAverageOverInSeconds; r=I64INT(result); test.Printf(_L("%S executed %d in 1 second\n"),&aTitle,r); return(result); }
/** @SYMTestCaseID SYSLIB-ECOM-CT-3163 @SYMTestCaseDesc Verify the startup behaviour of the ECOM server under OOM conditions @SYMTestPriority High @SYMTestActions Generate an OOM condition. Create a new thread which will launch the ECOM server. Wait for the thread to exit and check the thread exit type and reason to verify behaviour. @SYMTestExpectedResults The test must not fail. @SYMDEF DEF094675 */ void StartServer_OOMTest() { _LIT(KStartThreadName,"Server Start Thread"); //Create a new thread to launch the ECOM server RThread testThread; testThread.Create(KStartThreadName, ServerStartThreadEntryL, KDefaultStackSize,KMinHeapSize,KMinHeapSize,NULL); TRequestStatus status; testThread.Logon(status); testThread.Resume(); //Wait for the thread to exit User::WaitForRequest(status); //Obtain exit type and reason for test thread TExitType exitType = testThread.ExitType(); TInt exitReason = testThread.ExitReason(); //close the thread handle testThread.Close(); //Verify the exit reason and exit code //Exit type is TExitType::EExitKill when E32Main() exit normally TEST(exitType == EExitKill); TEST(exitReason == KErrNoMemory); }
TInt CAnvltestListener::StartThread(void) { TInt res = KErrNone; //RThread anvlThread; RThread *anvlThread; anvlThread = &iAnvlThread; iOriThreadId = RThread().Id(); res = anvlThread->Create(ANVL_THREAD_NAME, CAnvltestListener::ThreadFunction, KDefaultStackSize, KAnvlDefaultHeapSize, KAnvlDefaultHeapSize, this // passed as TAny* argument to thread function ); if ( res == KErrNone ) // thread created ok - now start it going { anvlThread->SetPriority(KAnvlThreadPriority); anvlThread->Resume(); // anvlThread->Close(); } else // thread not created ok { anvlThread->Close(); } return res; };
/** Static function used to create and start CSsmSwpPolicyServer @return KErrAlreadyExists if the server is already running */ EXPORT_C TInt CSsmSwpPolicyServer::StartSsmSwpPolicySrv(const TDesC& aServerName) { TAny* threadParam = reinterpret_cast<TAny*>(const_cast<TDesC*>(&aServerName)); // Create a Unique name for the thread name TName name(aServerName); _LIT(KUnderScore, "_"); name.Append(KUnderScore); name.AppendNum(Math::Random(), EHex); const TInt KSsmPolicySrvMinHeapSize = 0x2000; // 8kB const TInt KSsmPolicySrvMaxHeapSize = 10 * KSsmPolicySrvMinHeapSize; RThread srvThread; TInt err = srvThread.Create(name, &CSsmSwpPolicyServer::SsmSwpPolicySrvThreadFn, KDefaultStackSize, KSsmPolicySrvMinHeapSize, KSsmPolicySrvMaxHeapSize, threadParam, EOwnerProcess); DEBUGPRINT2(_L("CSsmSwpPolicyServer: SsmSwpPolicyServer created with %d") ,err); if(KErrNone == err) { TRequestStatus trs; srvThread.Rendezvous(trs); srvThread.Resume(); User::WaitForRequest(trs); err = trs.Int(); srvThread.Close(); } return err; }