void CAppfwkAmaStarterTestStepCancel::TestCase1L() { // Launch the appropriate AMAStarter(s) via CAmaStart::StartL() TRequestStatus myRequestStatus; CAmaStart* amaStart = CAmaStart::NewL(); CleanupStack::PushL(amaStart); amaStart->Start(TUid::Uid(0x10000017), myRequestStatus); TEST(myRequestStatus == KRequestPending); User::After(100000); // Wait for a tenth of a second to give the starter a chance to start something - if the cancel is issued without waiting, nothing is started. amaStart->CancelStart(); User::WaitForRequest(myRequestStatus); TEST(myRequestStatus == KErrCancel); INFO_PRINTF3(_L("CAmaStart->Start(TUid::Uid(0x10000017), &myRequestStatus) finished with request status '%d' (expected '%d')"), myRequestStatus.Int(), KErrCancel); //Check that the last item in the DSC didn't run RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); RFileReadStream rs; TInt ret = rs.Open(fs, KLogFileName, EFileShareExclusive|EFileRead); if (KErrNone != ret) { ERR_PRINTF2(_L("Could not open log file. Leave code: '%d'"), ret); User::LeaveIfError(ret); } rs.PushL(); const TInt KMaxCommandLength = 256; TBuf<KMaxCommandLength> commandLine; rs.ReadL(commandLine,1); TEST(commandLine.Compare(_L("9")) != 0); INFO_PRINTF2(_L("Checking log result: Expected not '9', Actual '%s'"), &commandLine); CleanupStack::PopAndDestroy(); //rs ret = fs.Delete(KLogFileName); if (KErrNone != ret) { ERR_PRINTF2(_L("Could not delete log file. Leave code: '%d'"), ret); User::LeaveIfError(ret); } // clean-up CleanupStack::PopAndDestroy(2,amaStart); // fs, amaStart }
void CJavaDebugAgentSettings::LoadL(const TDesC& aPrefsFile) { RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); RFileReadStream in; in.PushL(); User::LeaveIfError(in.Open(fs, aPrefsFile, EFileRead)); TRAPD(err, LoadL(&in)); in.Close(); in.Pop(); if (err != KErrNone) { err = fs.Delete(aPrefsFile); } CleanupStack::PopAndDestroy(&fs); }
/** Start a test application synchronously using Wait-for-Signal with timeout more than the time required for the application to start and which starts after the no. of retries given. */ void CSsTestStepAppTimeout::DoTestWaitForSignalWithMoreTimeOutAndWithRetriesL() { INFO_PRINTF1(_L("Performing Wait-for-Signal test with timeout and retries")); // Write the retry number to a file to be read, updated // and eventually deleted by the test-app. RFs fs; CleanupClosePushL( fs ); RFileWriteStream writeStream; CleanupClosePushL( writeStream ); User::LeaveIfError(fs.Connect()); User::LeaveIfError(writeStream.Replace(fs, KFileForFAndF, EFileWrite)); const TInt KSsTestRequiredDelay = 0; const TInt KSsTestFailCount = 1; const TInt KSsTestRetryCount = 0; writeStream.WriteInt8L(KSsTestRetryCount); writeStream.WriteInt8L(KSsTestFailCount); writeStream.WriteInt8L(KSsTestRequiredDelay); writeStream.CommitL(); writeStream.Close(); const TInt KRetries = KSsTestFailCount + 1; TInt completionCode = DoTestAndStopperL(KRetries, KWaitTimeForTestAppForFAndF * 3, KTestAppForFAndF); TEST(completionCode == 0); INFO_PRINTF2( _L("Anticipated completion code 0. Supplied completion code %d"),completionCode); RFileReadStream readStream; CleanupClosePushL(readStream); User::LeaveIfError(readStream.Open(fs, KFileForFAndF, EFileRead)); TInt retryCount = readStream.ReadInt8L(); readStream.Close(); fs.Delete(KFileForFAndF); CleanupStack::PopAndDestroy(3, &fs); TEST(1 == FindAndKill(KTestAppForFAndF)); TEST(retryCount == 1); INFO_PRINTF3( _L("ssmtestappsucessfulafterretry.exe is started after %d retries. anticipated retries value %d"),retryCount, 1); }
// ---------------------------------------------------------------------------- // CAudioStreamEngine::LoadAudioFileL() // // loads the audio data from a file into the buffer // ---------------------------------------------------------------------------- void CAudioStreamEngine::LoadAudioFileL() { RFileReadStream audiofile; // open file TFileName fileName; fileName.Copy(iAudioFilePath); fileName.Append(iAudioFile); TInt err = audiofile.Open(iFs, fileName, EFileRead|EFileStream); iStreamBuffer->Des().FillZ(iFrameCount * iFrameSize); // Empty the stream buffer if (err==KErrNone) { // file opened ok, proceed reading if (iUseAMR) { // Read the AMR header (the first 6 bytes). We don't need to save/use the header, // since while playback we already know it's an AMR-NB encoded stream. TBuf8<KAMRHeaderLength> temp; audiofile.ReadL(temp, KAMRHeaderLength); } TUint idx=0; while (idx < iFrameCount) { TRAPD(fstatus, audiofile.ReadL(GetFrame(idx), iFrameSize)); if (fstatus!=KErrNone) break; idx++; } iStreamStart=0; iStreamEnd=idx-1; ShowMessage(_L("CAudioStreamEngine::LoadAudioFileL() Loading complete!"), ETrue); iBufferOK = ETrue; } else { // failed to open file ShowMessage(_L("CAudioStreamEngine::LoadAudioFileL() Error loading audio sample!"), ETrue); iBufferOK = EFalse; } audiofile.Close(); }
EXPORT_C TInt TEFparser::ReadFileLC(RFs& aFs, const TDesC& aScriptFilepath, TPtrC& aScriptFileContents ) { RFile scriptFile; TInt err = scriptFile.Open(aFs, aScriptFilepath, EFileStream | EFileRead | EFileShareAny); if (err != KErrNone) { return KErrNotFound; } // gets size of ini file TInt size; scriptFile.Size(size); scriptFile.Close(); // reads ini into iTestInput HBufC* scriptFileH16 = HBufC::NewLC(size); HBufC8* scriptFileH = HBufC8::NewLC(size); //RBuf scriptFileR; TPtr8 pInput = scriptFileH->Des(); TPtr pInput16 = scriptFileH16->Des(); pInput.SetLength(size); RFileReadStream stream; User::LeaveIfError(stream.Open(aFs, aScriptFilepath, EFileStream | EFileRead | EFileShareReadersOnly)); CleanupClosePushL(stream); stream.ReadL(pInput,size); // stream.ReadL(pInput, size); pInput16.Copy(pInput); //scriptFileR.Assign(scriptFileH16); aScriptFileContents.Set(*scriptFileH16); CleanupStack::PopAndDestroy(2); // stream, testInput return KErrNone; }
/** Import contacts from the vCard file specified by aFileName */ void CAgentTest::ImportContactsL(const TDesC& aFileName) { RFileReadStream vcard; User::LeaveIfError(vcard.Open(iTest.Fs(), aFileName, EFileRead)); CleanupClosePushL(vcard); TBool success=EFalse; CArrayPtr<CContactItem>* contactItems=iDb->ImportContactsL(TUid::Uid(KUidVCardConvDefaultImpl), vcard, success, CContactDatabase::ETTFormat); CleanupStack::PopAndDestroy(&vcard); CleanupStack::PushL(TCleanupItem(CleanUpResetAndDestroy,contactItems)); iIdArray->Reset(); TContactItemId contactId; for(TInt loop = 0;loop < contactItems->Count();++loop) { contactId = (*contactItems)[loop]->Id(); iIdArray->AddL(contactId); } CleanupStack::PopAndDestroy(contactItems); }
HBufC8* CValidateTest::ReadFileLC(const TDesC& aFilename) { RFile file; User::LeaveIfError(file.Open(iFs, aFilename, EFileRead)); CleanupClosePushL(file); TInt size; file.Size(size); CleanupStack::PopAndDestroy(1);//fileClose HBufC8* res = HBufC8::NewLC(size); TPtr8 p(res->Des()); p.SetLength(size); RFileReadStream stream; User::LeaveIfError(stream.Open(iFs, aFilename, EFileStream)); CleanupClosePushL(stream); stream.ReadL(p, size); CleanupStack::PopAndDestroy();//streamClose...bleurgh return res; }
// ----------------------------------------------------------------------------- // CDRMHelperServer::RestoreL(). // This function restore internal list from data file // ----------------------------------------------------------------------------- // void CDRMHelperServer::RestoreL() { #ifdef _DRM_TESTING WriteL(_L8("RestoreL")); #endif TInt err = 0; RFileReadStream file; RFile test; err = test.Open( iFs , DataFileL(iFs).FullName() , EFileRead ); if ( !err ) { CleanupClosePushL(test); TInt size = 0; err = test.Size(size); User::LeaveIfError(err); CleanupStack::PopAndDestroy(&test); //test if (size == 0) { StoreL(); } } else if ( err == KErrNotFound ) { StoreL(); } else { User::Leave(err); } User::LeaveIfError(file.Open( iFs , DataFileL(iFs).FullName() , EFileRead )); file.PushL(); InternalizeL(file); CleanupStack::PopAndDestroy(&file); //file #ifdef _DRM_TESTING WriteL(_L8("RestoreL->End")); #endif }
////////////////////////////////////////////////////////////////////////////////// // Test fix for INC023303: CX509Certificate externalize - internalize don't work ////////////////////////////////////////////////////////////////////////////////// void CSyntaxTest::TestInternalizeExternalizeL(CX509Certificate* aCert) { RFileWriteStream newwriter; newwriter.PushL(); User::LeaveIfError(newwriter.Replace(iFs,_L("x509stream"),EFileStream)); aCert->ExternalizeL(newwriter); newwriter.CommitL(); CleanupStack::PopAndDestroy(1);//newwriter RFileReadStream newreader; newreader.PushL(); newreader.Open(iFs,_L("x509stream"),EFileStream); CX509Certificate* readCert=CX509Certificate::NewLC(newreader); //Use the stream to create new cert if (!readCert->IsEqualL(*aCert)) User::Leave(KErrGeneral); // iFs.Delete(_L("x509stream")); CleanupStack::PopAndDestroy(2); // readCert, newreader }
void TTcSettings::Load() { // Connect to file server RFs fs; if( fs.Connect() ) { return; } // Open the settings file for reading, it might not exist yet RFileReadStream in; if( !in.Open( fs, KTcSettingsFile, EFileRead ) ) { // Load actual data, ignore errors (the file might be of a previous // version and/or some items might be missing). TRAP_IGNORE( doLoadL( in ) ) } in.Close(); fs.Close(); }
/** @fn void ReadIniFileL() Open the ini file and read the contents. Intended for manually testing the write code. */ LOCAL_C void ReadIniFileL() { RFs fileSession; User::LeaveIfError(fileSession.Connect()); CleanupClosePushL(fileSession); RFileReadStream fileReadStream; User::LeaveIfError(fileReadStream.Open(fileSession, IniFileName, EFileRead)); CleanupClosePushL(fileReadStream); TInt32 value1 = 0; TInt8 value2 = 0; //read the KEComUid and KSsaUid value1 = fileReadStream.ReadInt32L(); value1 = fileReadStream.ReadInt32L(); value2 = fileReadStream.ReadInt8L(); // close: fileSession, fileReadStream CleanupStack::PopAndDestroy(2); }
/** @SYMTestCaseID PDS-STORE-CT-4042 @SYMTestCaseDesc Tests for attaching write stream and read stream to an encrypted stream. @SYMTestPriority High @SYMTestActions Encrypt data and write to a store.Read the encrypted data for decrypting and compare the result. @SYMTestExpectedResults Test must not fail @SYMDEF DEF135804 */ LOCAL_C void testEncryptionDataAttachL() { test.Next(_L(" @SYMTestCaseID:PDS-STORE-CT-4042 ")); CPBEncryptElement* elementKey = CPBEncryptElement::NewLC(KTestPassword); TParsePtrC parse(KFileLocationSpec); RFileWriteStream writeStream; writeStream.PushL(); User::LeaveIfError(writeStream.Replace(TheFs, parse.NameAndExt(), EFileWrite)); REncryptStream encryptStream; TRAPD(ret, encryptStream.AttachL(writeStream, *elementKey)); test(ret == KErrNone); encryptStream.PushL(); encryptStream << KTestDes; encryptStream.CommitL(); writeStream.CommitL(); CleanupStack::PopAndDestroy(2); // encryptStream, writeStream const CPBEncryptionData& encryptData = elementKey->EncryptionData(); CPBEncryptElement* newElementKey = CPBEncryptElement::NewLC(encryptData, KTestPassword); RFileReadStream readStream; readStream.PushL(); User::LeaveIfError(readStream.Open(TheFs, parse.NameAndExt(), EFileWrite)); RDecryptStream decryptStream; decryptStream.AttachL(readStream, *newElementKey); decryptStream.PushL(); decryptStream >> TheBuf; test(KTestDes == TheBuf); CleanupStack::PopAndDestroy(4, elementKey); }
void CJournalFile::ReadL() { RFileReadStream journalStream; User::LeaveIfError(journalStream.Open(iFs, iJournalFileName, EFileRead | EFileShareAny)); CleanupClosePushL(journalStream); // we need to check that any filenames read from the journal are on the // same drive as the journal itself TDriveUnit journalDrive(iJournalFileName); TInt err = KErrNone; while(err == KErrNone) { // read the next journal entry TRAP(err, ReadEntryL(journalStream, journalDrive)); if(err != KErrNone && err != KErrEof) { DEBUG_PRINTF2(_L("CJournalFile::ReadL() - CJournalFile::ReadEntryL() has left with error %d Leaving with this error!"), err); User::Leave(err); } } CleanupStack::PopAndDestroy(&journalStream); }
TCalLocalUid CDstIntUtils::ImportVCalL(RFs& aFs, CCalSession& aSession, CCalEntryView& aEntryView, const TDesC& aFileName) { RFileReadStream readStream; User::LeaveIfError(readStream.Open(aFs, aFileName, EFileRead)); CleanupClosePushL(readStream); // Create ptr array for new entries RPointerArray<CCalEntry> entryArray; CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfEntries, &entryArray)); CCalDataExchange* dataExchange = CCalDataExchange::NewL(aSession); CleanupStack::PushL(dataExchange); dataExchange->ImportL(KUidVCalendar, readStream, entryArray); TInt elements = entryArray.Count(); TCalLocalUid id = 0; if(elements > 0) { CCalEntry* entry = entryArray[0]; // add the first entry only while (entryArray.Count() > 1) { delete entryArray[1]; entryArray.Remove(1); } TInt success = 0; aEntryView.StoreL(entryArray, success); id = entryArray[0]->LocalUidL(); } CleanupStack::PopAndDestroy(dataExchange); CleanupStack::PopAndDestroy(); // ResetAndDestroyArrayOfEntries(entryArray) CleanupStack::PopAndDestroy(); // readStream.Close() return id; }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CNcdProviderUtils::ReadDatabaseVersionsL( const TDesC& aRootPath, TUint32& aGeneralVersion, TUint32& aPurchaseHistoryVersion ) { DLTRACEIN(("")); RBuf path; AppendPathsLC( path, aRootPath, NcdProviderDefines::KNcdDatabaseVersionFile ); RFileReadStream stream; CleanupClosePushL( stream ); User::LeaveIfError( stream.Open( FileSession(), path, EFileRead ) ); aGeneralVersion = stream.ReadUint32L(); aPurchaseHistoryVersion = stream.ReadUint32L(); CleanupStack::PopAndDestroy( 2, &path ); // stream, path DLTRACEOUT(("Versions, general: %d, purchase history: %d", aGeneralVersion, aPurchaseHistoryVersion )); }
void CTestImpExvCardSuiteStepBase::OpenVCFAndImportItemL(TBuf<80> aPath, RFs aFsSession, TInt aIndex) { User::LeaveIfError(aFsSession.Connect()); CleanupClosePushL(aFsSession); RFileReadStream readVCFStream; // Format buf to hold relevant vcf file TBuf<100> buf; buf.Zero(); #ifdef __WINS__ buf.Append(_L("c:")); #else TFileName processFileName = RProcess().FileName(); TParsePtrC parse(processFileName); buf.Append(parse.Drive()); #endif buf.Append(aPath); buf.AppendNum(aIndex); buf.Append(_L(".vcf")); // Open vcf file User::LeaveIfError(readVCFStream.Open(aFsSession, buf, EFileRead)); TBuf<MAX_TEXT_MESSAGE> message; message.Format(KOpenVCFFile, &buf); INFO_PRINTF1(message); CleanupClosePushL(readVCFStream); // Imports the vCard ImportCardL(readVCFStream); CleanupStack::PopAndDestroy(); // pop readVCFStream aFsSession.Close(); CleanupStack::PopAndDestroy(); // pop aFsSession }
// ----------------------------------------------------------------------------- // CSisxUIStartupFile::ReadPrivateStartupItemsL // Read startup items from private file. // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CSisxUIStartupFile::ReadPrivateStartupItemsL( RArray<TStartupTaskParam>& aStartupItems ) { RFileReadStream reader; reader.PushL(); User::LeaveIfError( reader.Open( iFileSession, *iPrivateFile, EFileRead ) ); // Read the number of entries TInt count = reader.ReadInt32L(); // Read file names from the file while ( count-- ) { TStartupTaskParam item; HBufC* fileName = HBufC::NewLC( reader, KMaxFileName ); item.iFileName.Copy( *fileName ); CleanupStack::PopAndDestroy( fileName); aStartupItems.Append( item ); } CleanupStack::PopAndDestroy(); // reader }
TBool CSupLoginServiceProvider::ReadDataFromFileL() { __LOGSTR_TOFILE("CSupLoginServiceProvider::ReadDataFromFileL() begins"); // If current operation should be cancelled if (iCancelStatus) return EFalse; TBool retValue = ETrue; RFs fsSession; RFileReadStream readStream; // Read stream from file // Install read file session User::LeaveIfError(fsSession.Connect()); CleanupClosePushL(fsSession); TInt err = readStream.Open(fsSession, iSettingsFile, EFileStream | EFileRead | EFileShareExclusive); CleanupClosePushL(readStream); // If file does not exist - return EFalse if (err != KErrNone) { retValue = EFalse; __LOGSTR_TOFILE("CSupLoginServiceProvider::ReadDataFromFileL() failed to open"); } if (retValue) { TInt valueMaxLen = 0; HBufC8* tempValue = NULL; // iMemberID valueMaxLen = readStream.ReadInt32L(); __LOGSTR_TOFILE("CSupLoginServiceProvider::ReadDataFromFileL() reading member id"); tempValue = HBufC8::NewL(readStream, valueMaxLen); if (tempValue) { if (iMemberID) { delete iMemberID; iMemberID = NULL; } iMemberID = tempValue->Des().AllocL(); delete tempValue; tempValue = NULL; } // iUsername valueMaxLen = readStream.ReadInt32L(); __LOGSTR_TOFILE("CSupLoginServiceProvider::ReadDataFromFileL() reading username"); tempValue = HBufC8::NewL(readStream, valueMaxLen); if (tempValue) { if (iUsername) { delete iUsername; iUsername = NULL; } iUsername = tempValue->Des().AllocL(); delete tempValue; tempValue = NULL; } // iPassword valueMaxLen = readStream.ReadInt32L(); __LOGSTR_TOFILE("CSupLoginServiceProvider::ReadDataFromFileL() reading password"); tempValue = HBufC8::NewL(readStream, valueMaxLen); if (tempValue) { if (iPassword) { delete iPassword; iPassword = NULL; } iPassword = tempValue->Des().AllocL(); delete tempValue; tempValue = NULL; } } // Free resource handlers CleanupStack::PopAndDestroy(&readStream); CleanupStack::PopAndDestroy(&fsSession); __LOGSTR_TOFILE("CSupLoginServiceProvider::ReadDataFromFileL() ends"); return retValue; }
// ---------------------------------------------------------------------------- // WidgetPreferences::PreferenceL // Get preference for a key // // // ---------------------------------------------------------------------------- TInt WidgetPreferences::preferenceL( const TDesC& akey, HBufC*& avalue) { TInt rSuccess = KErrNotFound; TInt size = 0; if ( !m_basepath || (m_basepath->Length() <= 0) ) return rSuccess; if ( akey.Length() <= KMaxKeyValueSize ) { HBufC* k = HBufC::NewLC( akey.Length() + KMaxIntLength + 1 ); k->Des().Format( KKeyFormat, m_widgetid, &akey ); PrefElement* pref = m_preferences->Find( *k ); if ( !pref ) { CleanupStack::PopAndDestroy( k ); return rSuccess; } size = pref->valueSize(); if ( size > KMaxKeyValueSize ) { // return contents from temp file whose name is stored // in the m_value member of m_preferences RFs fs; if ( fs.Connect() == KErrNone ) { CleanupClosePushL( fs ); HBufC* filePath = HBufC::NewLC( pref->value().Length() ); TPtr fName( filePath->Des() ); fName.Append( pref->value() ); RFileReadStream readStream; if ( readStream.Open( fs, *filePath, EFileRead ) == KErrNone ) { CleanupClosePushL( readStream ); TInt len( readStream.ReadInt32L() ); if ( len > 0 ) { HBufC* v = HBufC::NewLC( len ); TPtr ptrvalue = v->Des(); readStream.ReadL( ptrvalue, len ); avalue = v; // ownership xfered CleanupStack::Pop( v ); rSuccess = KErrNone; } CleanupStack::PopAndDestroy();//readStream } CleanupStack::PopAndDestroy( 2 ); //filePath,fs } } else if ( size >= 0 ) { avalue = pref->value().AllocL(); rSuccess = KErrNone; } CleanupStack::PopAndDestroy( k ); } return rSuccess; }
// --------------------------------------------------------------------------- // CLbtCleanupHandler::ReadCleanupDataFromFileL // --------------------------------------------------------------------------- // void CLbtCleanupHandler::ReadCleanupDataFromFileL() { FUNC_ENTER("CLbtCleanupHandler::ReadCleanupDataFromFileL"); // First reset the cleanup data iCleanupItems.ResetAndDestroy(); // Open handle to file system RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); // Obtain the file path TFileName file; // Gets the path in which the file can be created fs.SessionPath(file); // Create the file Directory ie the private directory of the process fs.MkDirAll(file); // Append the name of the file file.Append(KLbtAppCleanupFileName); // Open read stream RFileReadStream readStream; TInt error = readStream.Open( fs, file, EFileRead ); if( error != KErrNone ) { // File may not exists ERROR("Opening of cleanup file failed with : %d", error); readStream.Close(); CleanupStack::PopAndDestroy(); //fs return; } CleanupClosePushL( readStream ); // Get the count in the cleanup array TInt count = readStream.ReadInt16L(); for(TInt i=0; i<count; ++i) { RArray<TLbtTriggerId> triggers; CleanupClosePushL(triggers); // Read the trigger ids TInt triggerCount = readStream.ReadInt16L(); for(TInt j=0;j<triggerCount;++j) { triggers.Append( readStream.ReadUint32L() ); } // Read the universal time TInt year = readStream.ReadInt32L(); TMonth month = static_cast<TMonth>( readStream.ReadInt32L() ); TInt day = readStream.ReadInt32L(); TDateTime dateTime( year, month, day, 0, 0, 0, 0 ); TTime time( dateTime ); CLbtCleanupItem* cleanupItem = new (ELeave) CLbtCleanupItem(); cleanupItem->AddCleanupItem( triggers, time ); CleanupStack::Pop(); // triggers triggers.Close(); // Append cleanup item to the cleaup items array iCleanupItems.Append( cleanupItem ); } CleanupStack::PopAndDestroy(2); // fs and readStream }
EXPORT_C TInt CSenLogger::CreateL(TInt aChannel, TInt aLevel, const TDesC& aLogDir, const TDesC& aLogFileName, TFileLoggingMode aMode) { TInt index(KErrNotFound); CSenLogger* pSenLogger = NULL; TWsTls* tls = (TWsTls*)Dll::Tls(); if( !tls ) { tls = new (ELeave) TWsTls(); tls->iLogger = NULL; tls->iProxy = NULL; Dll::SetTls( tls ); } pSenLogger = tls->iLogger; if ( !pSenLogger ) { pSenLogger = new (ELeave) CSenLogger(); if ( pSenLogger ) { tls->iLogger = pSenLogger; pSenLogger->iCount = 0; //reading the configuration file for the logging levels!!! /*the file has the following format (IN ANSI) * ============================================================================== * LogChannel LogLevel 1000 0 2000 1 . . . . . .... 18000 2 this means first you need to write the channel followed by the corresponding logging level after a space the file has to be located under C:\Config.txt * ==============================================================================*/ TInt res; RFs fs; res=fs.Connect(); if(res==KErrNone) { RFileReadStream readStream; res=readStream.Open(fs, KPath, EFileRead|EFileStreamText); if(res == KErrNone) { TInt error; TInt retVal; do { TBuf8<128> readLineBuf; TRAP(error, readStream.ReadL(readLineBuf, (TChar)'\n')); if(error == KErrNone) { TInt32 length(0); length = readLineBuf.Length() ; TInt *key = new (ELeave) TInt; TLex8 lexBuf(readLineBuf); retVal = lexBuf.Val(*key); if(retVal!=0) { delete key; continue; } else { TInt *value = new (ELeave) TInt; lexBuf.SkipSpace(); retVal=lexBuf.Val(*value); if(retVal==0) { retVal = pSenLogger->iMap.Append(key,value); if(retVal != KErrNone) { delete key; delete value; } } else { delete key; delete value; } } } }while(error == KErrNone); readStream.Close(); } fs.Close(); } } else { return KErrGeneral; } } else { index = pSenLogger->ChannelIndex(aChannel); } if (index == KErrNotFound) { TInt channelIndex; TLog* pTLog = new (ELeave) TLog; CleanupStack::PushL(pTLog); pTLog->iChannel=aChannel; channelIndex=pSenLogger->iMap.Find(aChannel); if(channelIndex==KErrNotFound) { pTLog->iLevel=aLevel; } else { pTLog->iLevel=*(pSenLogger->iMap.ValueAt(channelIndex)); } pTLog->iCount=1; pTLog->iLog.Connect(); pTLog->iLog.CreateLog(aLogDir, aLogFileName, aMode); pTLog->iLog.Write(_L("SenTLSLogger - Log file opened")); #ifdef EKA pSenLogger->iLogs.AppendL(pTLog); #else User::LeaveIfError(pSenLogger->iLogs.Append(pTLog)); #endif CleanupStack::Pop(pTLog); } else { pSenLogger->iLogs[index]->iCount++; } pSenLogger->iCount++; return KErrNone; }
void CGsaStateTranToDiffStatesTest::DoStateRequestTransitionToDiffStatesL() { INFO_PRINTF1(_L("DoStateRequestTransitionToDiffStates test started....")); RFs fs; TInt err = fs.Connect(); TEST(err == KErrNone); User::LeaveIfError(err); CleanupClosePushL(fs); if (iProcessName == KTestProcTranFromNormal) { RFileReadStream fileReadStream1; err = fileReadStream1.Open(fs, KGsaTestStateTranFromNormalResult, EFileRead); INFO_PRINTF2(_L("Error in opening file: %d"), err); TEST(err == KErrNone); User::LeaveIfError(err); CleanupClosePushL(fileReadStream1); //System state before starting the test. CurrentSystemStateForStateTranTestL(fileReadStream1, ESsmNormal); //Scenario 1 - Request for state change from Normal to invalid state results in KErrNotSupported INFO_PRINTF1(_L("Request for state change from Normal to invalid state")); TInt stateTranResult = fileReadStream1.ReadInt32L(); TEST(stateTranResult == KErrNotSupported); INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream1, ESsmNormal); //Scenario 2 - Request for state change from Normal to fail state with invalid substate results in KErrNotSupported INFO_PRINTF1(_L("Request for state change from Normal to fail state with invalid substate")); stateTranResult = fileReadStream1.ReadInt32L(); TEST(stateTranResult == KErrNotSupported); INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream1, ESsmNormal); //Scenario 3 - Request for two state changes(1. fail state 2. shutdown state) one after the other without waiting // for the first one to complete. Cancels both transition request. INFO_PRINTF1(_L("Request for two state changes(1. fail state 2. shutdown state)")); INFO_PRINTF1(_L("one after the other without waiting for the first one to complete.")); INFO_PRINTF1(_L("Cancel the fail state transition request.")); stateTranResult = fileReadStream1.ReadInt32L(); TEST(stateTranResult == KErrCancel); INFO_PRINTF2(_L("First request to the fail state will be completed with %d Expected -3"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream1, ESsmNormal); stateTranResult = fileReadStream1.ReadInt32L(); TEST(stateTranResult == KErrCancel); INFO_PRINTF2(_L("Second request to transit to the shutdown state will be completed with %d Expected -3"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream1, ESsmNormal); INFO_PRINTF2(_L("Test process exits with %d Expected -3"), stateTranResult); CleanupStack::PopAndDestroy(); // Delete the result file //err = fs.Delete(KGsaTestStateTranFromNormalResult); RFileReadStream fileReadStream2; err = fileReadStream2.Open(fs, KGsaTestStateTranToShutdownResult, EFileRead); TEST(err == KErrNone); User::LeaveIfError(err); CleanupClosePushL(fileReadStream2); //System state before starting the test. CurrentSystemStateForStateTranTestL(fileReadStream2, ESsmNormal); //Scenario 1 - Request for state transition to shutdown state - invalid substate // request to transit to the shutdown state will be completed with KErrNotSupported INFO_PRINTF1(_L("Request for state transition to shutdown state - invalid substate")); stateTranResult = fileReadStream2.ReadInt32L(); TEST(stateTranResult == KErrNotSupported); INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream2, ESsmNormal); INFO_PRINTF2(_L("Test process exits with %d Expected -5"), stateTranResult); CleanupStack::PopAndDestroy(); // Delete the result file //err = fs.Delete(KGsaTestStateTranToShutdownResult); RFileReadStream fileReadStream3; err = fileReadStream3.Open(fs, KGsaTestStateTranFromShutdownResult, EFileRead); TEST(err == KErrNone); User::LeaveIfError(err); CleanupClosePushL(fileReadStream3); //System state before starting the test. CurrentSystemStateForStateTranTestL(fileReadStream3, ESsmNormal); //Scenario 1 - Request for state change from Normal to shutdown state to critical substate // Cancel the request immediately INFO_PRINTF1(_L("Request for state change from Normal to shutdown critical substate and Cancel the request")); stateTranResult = fileReadStream3.ReadInt32L(); TEST(stateTranResult == KErrCancel); INFO_PRINTF2(_L("Actual : %d Expected : -3"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream3, ESsmNormal); //Scenario 2 - Request for state change from Normal to shutdown state to any substate // Cancel the request immediately, so that we can proceed with the next test scenario. INFO_PRINTF1(_L("Request for state change from Normal to shutdown any substate and Cancel the request")); stateTranResult = fileReadStream3.ReadInt32L(); TEST(stateTranResult == KErrCancel); INFO_PRINTF2(_L("Actual : %d Expected : -3"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream3, ESsmNormal); INFO_PRINTF2(_L("Test process exits with %d Expected -3"), stateTranResult); CleanupStack::PopAndDestroy(); // Delete the result file //err = fs.Delete(KGsaTestStateTranFromShutdownResult); } else if(iProcessName == KTestProcTranFromStartup) { RFileReadStream fileReadStream; err = fileReadStream.Open(fs, KGsaTestStateTranFromStartupResult, EFileRead); TEST(err == KErrNone); User::LeaveIfError(err); CleanupClosePushL(fileReadStream); //System state before starting the test. CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup); //Scenario 1 - Request for state change from Startup to invalid state INFO_PRINTF1(_L("Request for state change from Startup to invalid state")); TInt stateTranResult = fileReadStream.ReadInt32L(); TEST(stateTranResult == KErrNotSupported); INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult); CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup); INFO_PRINTF2(_L("Test process exits with %d Expected -5"), stateTranResult); CleanupStack::PopAndDestroy(); // Delete the result file //err = fs.Delete(KGsaTestStateTranFromStartupResult); } else { TEST(err == KErrArgument); return; } CleanupStack::PopAndDestroy(); INFO_PRINTF1(_L("case completed\n")); }