// ----------------------------------------------------------------------------- // TMSCallServer::StartThreadL // // ----------------------------------------------------------------------------- // void TMSCallServer::StartThreadL(TMSCallServerStartParam& aStart) { TRACE_PRN_FN_ENT; CActiveScheduler* sched = new (ELeave) CActiveScheduler; CleanupStack::PushL(sched); CActiveScheduler::Install(sched); TMSCallServer* server = TMSCallServer::NewL(aStart.iTMSServer); CleanupStack::PushL(server); //Rename tmscall server name RThread tmscallServerThread; TThreadId threadId; TName name; name.Append(KTMSCallServerName); threadId = tmscallServerThread.Id(); name.AppendNum(threadId.Id(), EHex); //We are ignoring the error code returned from User::RenameThread //as it is not important here, may be for profiling User::RenameThread(name); aStart.iTMSCallServerHandle = server->Server(); // Sync with the client and enter the active scheduler RThread::Rendezvous(KErrNone); sched->Start(); CleanupStack::PopAndDestroy(server); // server CleanupStack::PopAndDestroy(sched); // sched TRACE_PRN_FN_EXT; }
// --------------------------------------------------------------------------- // CBSServer::DisplaySessionInfoL display the info for each open session, // except for the one that called this method // --------------------------------------------------------------------------- // void CBSServer::DisplaySessionInfoL( CBSSession* aSession, TInt aErrorCode ) { TRACE( T_LIT( "CBSServer::DisplaySessionInfoL() begin aSession[%d], aErrorCode[%d]"),aSession,aErrorCode ); User::LeaveIfNull( aSession ); // some constants const TInt KStringLength = 512; const TInt KNumberLength = 16; _LIT( KMessage0,"Operation failed.Errorcode:"); _LIT( KMessage1," Info on open sessions [ProcessFileName|ThreadId|ProcessId|Caption]:"); _LIT( KBracketOpen, " ["); _LIT( KBracketClose, "]"); _LIT( KSeparator, "|"); HBufC* outputString = HBufC::NewLC( KStringLength ); TPtr outputStringPtr( outputString->Des() ); TBuf<KNumberLength> number; number.Num( aErrorCode ); //make sure the string is long enough TInt newLength = outputString->Length() + KMessage0().Length() + number.Length() + KMessage1().Length(); //reallocate if necessary if ( outputStringPtr.MaxLength() < newLength ) { CleanupStack::Pop( outputString ); outputString = outputString->ReAllocL( newLength ); outputStringPtr.Set( outputString->Des() ); CleanupStack::PushL( outputString ); } outputStringPtr.Append( KMessage0 ); outputStringPtr.Append( number ); outputStringPtr.Append( KMessage1 ); TInt count = iSessions.Count(); TRACE( T_LIT( "CBSServer::DisplaySessionInfoL() numberSessions=%d"),count ); CBSSession* currentSession; for( TInt i = 0; i < count; i++ ) { currentSession = iSessions[i]; TRACE( T_LIT( "CBSServer::DisplaySessionInfoL() iteration=%d session=%d"),i,currentSession ); if ( currentSession && currentSession->InfoAvailable() && currentSession != aSession ) { TBuf<KNumberLength> threadIdStr; TThreadId threadId; if ( KErrNone == currentSession->ThreadId( threadId ) ) { threadIdStr.NumUC( threadId.Id(), EDecimal ); } TBuf<KNumberLength> processIdStr; TProcessId processId; if ( KErrNone == currentSession->ProcessId( processId ) ) { processIdStr.NumUC( processId.Id(), EDecimal ); } //make sure the string is long enough newLength = outputString->Length() + KBracketOpen().Length() + currentSession->FileName().Length() + threadIdStr.Length() + processIdStr.Length() + currentSession->Caption().Length() + ( 3 * KSeparator().Length() ) + KBracketClose().Length(); //reallocate if necessary if ( outputStringPtr.MaxLength() < newLength ) { CleanupStack::Pop( outputString ); outputString = outputString->ReAllocL( newLength ); outputStringPtr.Set( outputString->Des() ); CleanupStack::PushL( outputString ); } outputStringPtr.Append( KBracketOpen ); //processfilename outputStringPtr.Append( currentSession->FileName() ); outputStringPtr.Append( KSeparator ); //threadid outputStringPtr.Append( threadIdStr ); outputStringPtr.Append( KSeparator ); //processid outputStringPtr.Append( processIdStr ); outputStringPtr.Append( KSeparator ); //caption outputStringPtr.Append( currentSession->Caption() ); outputStringPtr.Append( KBracketClose ); } } TRACE( T_LIT( "CBSServer::DisplaySessionInfoL() string creation OK") ); TRACE( T_LIT( "%S"), outputString ); CleanupStack::PopAndDestroy( outputString ); TRACE( T_LIT( "CBSServer::DisplaySessionInfoL() end") ); }
/** @SYMTestCaseID GRAPHICS-FBSERV-0512 @SYMTestCaseDesc Creates bitmaps in different ways and checks if memory allocation succeeded @SYMTestActions Creates normal size bitmaps, large bitmaps, loads bitmaps, loads shared bitmaps, duplicated bitmaps, resizes bitmaps, compresses bitmaps, externalized bitmaps to write store, internalizes bitmaps back again from write store. All ways of creating bitmaps are tested against Out Of Memory error conditions @SYMTestExpectedResults Test should pass */ void CTAlloc::BitmapsL() { TInt heapMarkCheckFlag; if( !iStep->GetIntFromConfig(KDefaultSectionName, KFbsHeapMarkCheckFlag, heapMarkCheckFlag) ) { INFO_PRINTF1(_L("Error reading ini file")); User::Leave(KErrNotFound); } CFbsBitmap iBitmap; CFbsBitmap iBitmap2; iTestBitmapName = KTestBitmapOnZ; TInt ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL); TEST2(ret, KErrNone); ret = iBitmap.Create(KLargeSize,EColor256); // Expand server caches TEST2(ret, KErrNone); iBitmap.Reset(); TInt count; // Create bitmap INFO_PRINTF1(_L("CFbsBitmap::Create()\r\n")); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Create(KSmallSize,EColor256); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret=iBitmap.Create(KSmallSize,EGray2); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // Create (large) for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Create(KLargeSize,EColor256); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Create(KLargeSize,EColor256); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // Load INFO_PRINTF1(_L("CFbsBitmap::Load()\r\n")); ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL); TEST2(ret, KErrNone); iBitmap.Reset(); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // Load (shared) INFO_PRINTF1(_L("CFbsBitmap::Load() - shared \r\n")); // Do an initial load to ensure the StreamId cache does not get updated whilst OOM testing ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue); TEST2(ret, KErrNone); iBitmap.Reset(); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } continue; } else if (ret != KErrNone) TEST2(ret, KErrNone); ret = iBitmap2.Load(iTestBitmapName,ETfbs,ETrue); if (ret == KErrNoMemory) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } continue; } else if (ret == KErrNone) { iBitmap.Reset(); iBitmap2.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } continue; } else if (ret != KErrNone) TEST2(ret, KErrNone); ret = iBitmap2.Load(iTestBitmapName,ETfbs,ETrue); if (ret == KErrNoMemory) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } continue; } else if (ret == KErrNone) { iBitmap.Reset(); iBitmap2.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // Duplicate CFbsBitmap bmpalt; ret = bmpalt.Create(KSmallSize,EColor256); TEST2(ret, KErrNone); INFO_PRINTF1(_L("CFbsBitmap::Duplicate()\r\n")); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Duplicate(bmpalt.Handle()); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==1); ret = bmpalt.Create(KSmallSize,EColor256); TEST2(ret, KErrNone); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Duplicate(bmpalt.Handle()); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); bmpalt.Reset(); TEST(iFbs->ResourceCount()==0); // Resize // force fbserv to do a resize. This makes the pile to insert an index in it's array // If the array is empty when the tests below are run then the insert will look like a mem leak ret=iBitmap.Create(KLargeSize,EColor256); iBitmap.Resize(KLargeSizeAlt); iBitmap.Reset(); ret=iBitmap.Create(KSmallSize,EColor256); TEST2(ret, KErrNone); INFO_PRINTF1(_L("CFbsBitmap::Resize()\r\n")); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Resize(KSmallSizeAlt); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // force fbserv to do a resize. This makes the pile to insert an index in it's array // If the array is empty when the tests below are run then the insert will look like a mem leak ret=iBitmap.Create(KLargeSize,EColor256); iBitmap.Resize(KLargeSizeAlt); iBitmap.Reset(); ret=iBitmap.Create(KLargeSize,EColor256); TEST2(ret, KErrNone); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Resize(KLargeSizeAlt); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // Compress ret=iBitmap.Create(KSmallSize,EColor256); TEST2(ret, KErrNone); INFO_PRINTF1(_L("CFbsBitmap::Compress()\r\n")); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Compress(); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); ret=iBitmap.Create(KLargeSize,EColor256); TEST2(ret, KErrNone); INFO_PRINTF1(_L("CFbsBitmap::Compress()\r\n")); for (count = 1; ; count++) { iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } ret = iBitmap.Compress(); if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); // WriteStore creation RFs fs; ret=fs.Connect(); TEST2(ret, KErrNone); CDirectFileStore* writestore=NULL; //Construct filename using the thread id to enable concurrent test runs. _LIT(KSbmFileName,"c:\\tall_"); TBuf<36> buf(KSbmFileName); TThreadId threadId = RThread().Id(); TUint64 id = threadId.Id(); TBuf<20> threadIdBuf; threadIdBuf.Num(id); buf.Append(threadIdBuf); buf.Append(_L(".sbm")); TRAP(ret,writestore=CDirectFileStore::ReplaceL(fs,buf,EFileStream|EFileWrite)); TEST2(ret, KErrNone); TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid); TRAP(ret,writestore->SetTypeL(uidtype)); TEST2(ret, KErrNone); RStoreWriteStream writestrm; TStreamId headerid(0); TRAP(ret,headerid=writestrm.CreateL(*writestore)); TEST2(ret, KErrNone); TRAP(ret,writestore->SetRootL(headerid)); TEST2(ret, KErrNone); // Externalize ret=iBitmap.Create(KSmallSize,EColor256); TEST2(ret, KErrNone); INFO_PRINTF1(_L("CFbsBitmap::ExternalizeL()\r\n")); for (count = 1; ; count++) { __UHEAP_SETFAIL(RHeap::EDeterministic,count); __UHEAP_MARK; TRAP(ret,iBitmap.ExternalizeL(writestrm)); if (ret == KErrNoMemory) { __UHEAP_MARKEND; } else if (ret == KErrNone) { iBitmap.Reset(); __UHEAP_MARKEND; break; } else { __UHEAP_MARKEND; TEST2(ret, KErrNone); } } __UHEAP_RESET; TEST(iFbs->ResourceCount()==0); // ExternalizeRectangle ret=iBitmap.Create(KSmallSize,EColor256); TEST2(ret, KErrNone); INFO_PRINTF1(_L("CFbsBitmap::ExternalizeRectangleL()\r\n")); for (count = 1; ; count++) { __UHEAP_SETFAIL(RHeap::EDeterministic,count); __UHEAP_MARK; TRAP(ret,iBitmap.ExternalizeRectangleL(writestrm,TRect(3,3,7,7))); if (ret == KErrNoMemory) { __UHEAP_MARKEND; } else if (ret == KErrNone) { __UHEAP_MARKEND; break; } else { __UHEAP_MARKEND; TEST2(ret, KErrNone); } } __UHEAP_RESET; writestrm.Close(); delete writestore; iBitmap.Reset(); TEST(iFbs->ResourceCount()==0); // Internalize INFO_PRINTF1(_L("CFbsBitmap::InternalizeL()\r\n")); for (count = 1; ; count++) { // ReadStore creation CDirectFileStore* readstore=NULL; TRAP(ret,readstore=CDirectFileStore::OpenL(fs,buf,EFileStream|EFileRead|EFileShareAny)); TEST2(ret, KErrNone); RStoreReadStream readstrm; headerid=readstore->Root(); TRAP(ret,readstrm.OpenL(*readstore,headerid)); TEST2(ret, KErrNone); iFbs->SendCommand(EFbsMessDefaultAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } TRAP(ret,iBitmap.InternalizeL(readstrm)); readstrm.Close(); delete readstore; if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); for (count = 1; ; count++) { // ReadStore re-creation CDirectFileStore* readstore=NULL; // TRAP(ret,readstore=CDirectFileStore::OpenL(fs,_L("c:\\tall.sbm"),EFileStream|EFileRead|EFileShareAny)); TRAP(ret,readstore=CDirectFileStore::OpenL(fs,buf,EFileStream|EFileRead|EFileShareAny)); TEST2(ret, KErrNone); headerid=readstore->Root(); RStoreReadStream readstrm; TRAP(ret,readstrm.OpenL(*readstore,headerid)); TEST2(ret, KErrNone); iFbs->SendCommand(EFbsMessUserAllocFail,count); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMark); iFbs->SendCommand(EFbsMessUserMark); } TRAP(ret,iBitmap.InternalizeL(readstrm)); readstrm.Close(); delete readstore; if (ret == KErrNoMemory) { if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } } else if (ret == KErrNone) { iBitmap.Reset(); if(heapMarkCheckFlag) { iFbs->SendCommand(EFbsMessDefaultMarkEnd); iFbs->SendCommand(EFbsMessUserMarkEnd); } break; } else TEST2(ret, KErrNone); } iFbs->SendCommand(EFbsMessDefaultAllocFail,0); iFbs->SendCommand(EFbsMessUserAllocFail,0); TEST(iFbs->ResourceCount()==0); fs.Delete(buf); fs.Close(); }
void CServerCrashDataSource::DoGetListL(const TListId aListId, const TThreadId aThreadId, const TProcessId aProcessId, RBuf8 & aBuffer, TUint32 & aSize ) { LOG_MSG5( "->CServerCrashDataSource::DoGetList(aListId=%d, aThredId=%Lu, aProcessId=%Lu, aSize=%d\n", aListId, aThreadId.Id(), aProcessId.Id(), aSize ); TInt ret; TListLevel listLevel; if( ((TUint)-1 == (TUint)aThreadId) && ((TUint)-1 == (TUint)aProcessId) ) { listLevel = EListGlobal; ret = iSecSess.GetList( aListId, aBuffer, aSize ); } else if( ((TUint)-1 != (TUint)aThreadId) && ((TUint)-1 == (TUint)aProcessId) ) { listLevel = EListThread; LOG_MSG("CServerCrashDataSource::DoGetList - EListThread"); ret = iSecSess.GetList( aThreadId, aListId, aBuffer, aSize ); } else { listLevel = EListProcess; LOG_MSG("CServerCrashDataSource::DoGetList - EListProcess"); ret = iSecSess.GetList( aProcessId, aListId, aBuffer, aSize ); } while( KErrTooBig == ret ) { LOG_MSG2( "CServerCrashDataSource::DoGetListL - list too big, new size=%d\n", aSize ); // Too big, and aSize should have been modified to the required new size // Since the list could have increased in size between calls, give it an // extra margin. aSize += 256; aBuffer.ReAllocL( aSize ); if( EListGlobal == listLevel ) { ret = iSecSess.GetList( aListId, aBuffer, aSize ); } else if( EListThread == listLevel ) { ret = iSecSess.GetList( aThreadId, aListId, aBuffer, aSize ); } else { ret = iSecSess.GetList( aProcessId, aListId, aBuffer, aSize ); } } User::LeaveIfError(ret); }
TVerdict CProcessLaunchTest0Step::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. */ { _LIT(KThreadName, "*lbsgpslocmanager*"); TProcessStartParams processParams; _LIT(KDummyFileName, "\\sys\\bin\\lbsgpslocmanager.exe"); _LIT(KDummyProcessName, "DummyAgpsManager"); processParams.SetProcessFileName(KDummyFileName); processParams.SetProcessName(KDummyProcessName); processParams.SetRendezvousRequired(EFalse); if (TestStepResult()==EPass) { CProcessLaunch::ProcessLaunch(processParams); // now we have to look for this thread. TFindThread threadFinder(KThreadName); TFullName matchedThreadName; // see how many instances we have of the thread TInt matchCount = 0; while(threadFinder.Next(matchedThreadName) == KErrNone) { ++matchCount; } // match count must be one at this point if(matchCount!=1) { // fail the test, its all gone very wrong - there are 2 processes SetTestStepResult(EFail); } // now we want to grab the ThreadID (we can just use thead id's, don't need handles) RThread processThread; User::LeaveIfError(processThread.Open(matchedThreadName)); TThreadId tid = processThread.Id(); // now try and break things, by starting a 2nd copy of the process. CProcessLaunch::ProcessLaunch(processParams); // NB we use the same process params matchCount = 0; threadFinder.Find(KThreadName); while(threadFinder.Next(matchedThreadName)==KErrNone) { ++matchCount; } // match count must be one at this point if(matchCount!=1) { // fail the test, its all gone very wrong - there are 2 processes // this is were we will fail with the current code. SetTestStepResult(EFail); } // check the thread ID's RThread newProcessThread; User::LeaveIfError(newProcessThread.Open(matchedThreadName)); TThreadId newTid = newProcessThread.Id(); if(newTid.Id() != tid.Id()) { // fail the test these are different thread id's // This is to be expected in the current code base SetTestStepResult(EFail); } else { // test passes - there is only one instance of the process SetTestStepResult(EPass); } } // now kill the process we started _LIT(KStar, "*"); TFullName wildCardPattern; wildCardPattern.Append(KStar); wildCardPattern.Append(KThreadName); wildCardPattern.Append(KStar); TFindProcess pf(wildCardPattern); TFullName name; TInt findError = pf.Next(name); RProcess p; TInt pErr = 0; pErr = p.Open(name); User::LeaveIfError(pErr); // nuke it p.Kill(0); p.Close(); return TestStepResult(); }