void CTestImpExvCardSuiteStepBase::OpenBDAYVCFAndImportItemL(TBuf<80> aPath,TInt aIndex)
{
// Format buf to hold relevant vcf file
TFileName fileName;
#ifdef __WINS__
fileName.Append(_L("c:"));
#else
TFileName processFileName = RProcess().FileName();
TParsePtrC parse(processFileName);
fileName.Append(parse.Drive());
#endif
fileName.Append(aPath);
fileName.AppendNum(aIndex);
fileName.Append(_L(".vcf"));
RFs fs;
User::LeaveIfError(fs.Connect()); // push fs
CleanupClosePushL(fs);
RFileReadStream readVCFStream;
User::LeaveIfError(readVCFStream.Open(fs, fileName, EFileRead)); // opens vcf file
TBuf<MAX_TEXT_MESSAGE> message;
message.Format(KOpenVCFFile, &fileName);
INFO_PRINTF1(message);
CleanupClosePushL(readVCFStream); // readVCFStream
ImportBDAYCardL(readVCFStream);
CleanupStack::PopAndDestroy(); // pop readVCFStream
fs.Close();
CleanupStack::PopAndDestroy(); // pop fs
}
void CAccessCountTests::ImportVcardL()
{
TBool sucess = EFalse;
RFileReadStream rfrs;
CleanupClosePushL( rfrs );
User::LeaveIfError( rfrs.Open( iParent->Fs(), KVcardFile, EFileRead | EFileShareAny ) );
FOREVER
{
CArrayPtr<CContactItem>* imported= iContactsDatabase->ImportContactsL(
TUid::Uid( KUidVCardConvDefaultImpl ), rfrs, sucess,
CContactDatabase::EIncludeX | CContactDatabase::ETTFormat |
CContactDatabase::EImportSingleContact
);
if(sucess)
{
imported->ResetAndDestroy();
CLEAR(imported);
}
else
{
imported->ResetAndDestroy();
CLEAR(imported);
break;
}
sucess = EFalse;
}
CleanupStack::PopAndDestroy(&rfrs);
}
void CIncallertAppUi::DoConstuctL()
{
//at first start iAppView would be null as all member ptrs are NULL (defaulted by (ELeave) in CIncallertDocument::CreateAppUiL())
if(iAppView)//if already called before - just to make sure there's no duplicate ctor alloc
return;
iAppView = CIncallertAppView::NewL(this);
iSettingsView = CIncallertSettingsView::NewL(this);
iLineStatusHandler = CLineStatusHandler::NewL(this);
iHelpAppView = CHelpAppView::NewL( ENavigationPaneHelpViewId);
iAboutAppView = CAboutAppView::NewL( ENavigationPaneAboutViewId);
_LIT(KIni,"Incallert.ini");
TFileName fname(KIni);
#ifndef __WINS__
CompleteWithPrivatePathL(fname);
#endif
TSettingsListSettings settings;
TRAPD(err,
RFs fs = iCoeEnv->FsSession();
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFileReadStream rfrs;
if(rfrs.Open(fs,fname,EFileRead) == KErrNone)
{
CleanupClosePushL(rfrs);
settings.InternalizeL(rfrs);
CleanupStack::PopAndDestroy();
}
CleanupStack::PopAndDestroy();
);
// ---------------------------------------------------------------------------
// Restore the file from given directory and given index
// ---------------------------------------------------------------------------
//
EXPORT_C CXIMPTestFileSrvMsg* CXIMPTestFileTool::SrvMsgRestoreLC(
TInt aObjIndex )
{
CXIMPTestFileSrvMsg* msg = CXIMPTestFileSrvMsg::NewLC();
HBufC* fileName = GetFileNameLC(
KFileToolSrvDirBase,
aObjIndex );
// try to instantiate it
RFileReadStream in;
CleanupClosePushL( in );
in.Open( iFs, *fileName, EFileStream );
msg->InternalizeL( in );
CleanupStack::PopAndDestroy(); // in
// delete the just read object
iFs.Delete( *fileName );
CleanupStack::PopAndDestroy( fileName ); // fileName
return msg;
}
void VersitImportContactL(const TDesC& aImportFileName)
{
RFileReadStream readStream;
//Import aImportFileName
User::LeaveIfError(readStream.Open(fsSession, aImportFileName, EFileRead));
CleanupClosePushL(readStream);
TBool success=EFalse;
CArrayPtr<CContactItem>* contactItems=CntTest->Db()->ImportContactsL(TUid::Uid(KUidVCardConvDefaultImpl),
readStream, success,
CContactDatabase::EImportSingleContact+CContactDatabase::ETTFormat);
//Should be the only contact in the database at this point
TInt count = CntTest->Db()->CountL();
test(count == 1);
//Store the id of the new contact - we need this later
TContactItemId contactId = (*contactItems)[0]->Id();
CntTest->Db()->SetCurrentItem(contactId);
readStream.Close();
CleanupStack::PopAndDestroy(); //readStream.Close()
contactItems->ResetAndDestroy();
delete contactItems;
}
void CEmTubePlaylist::ConstructL( RFileReadStream& aStream )
{
TInt l = aStream.ReadInt32L();
if( l )
{
iName = HBufC::NewL( l );
TPtr pName( iName->Des() );
aStream.ReadL( pName, l );
}
else
{
iName = KNullDesC().AllocL();
}
iType = (TEmTubePlaylistType)aStream.ReadInt32L();
iFlags = aStream.ReadInt32L();
TInt count = aStream.ReadInt32L();
for(TInt i=0;i<count;i++)
{
CEmTubePlaylistEntry* e = CEmTubePlaylistEntry::NewLC();
e->ImportL( aStream );
iEntries.AppendL( e );
CleanupStack::Pop( e );
}
}
/**
Reads the input config file created by sysstart_apparc_setup.bat and returns the
test case number (Defined in sysstart_apparc_run.bat)
@return TInt - the test case number
*/
TInt CSysStartApparcTestCase::ReadConfigFileL()
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFileReadStream reader;
User::LeaveIfError(reader.Open(fs, KApparcConfigFile, EFileRead));
CleanupClosePushL(reader);
TChar delimChar('=');
TBuf8<255> aDes;
reader.ReadL(aDes, delimChar);
//Read in a two character representation of a number and convert to an integer
TChar result1(reader.ReadInt8L());
TChar result0(reader.ReadInt8L());
TInt aTestCase = result1.GetNumericValue()*10 + result0.GetNumericValue();
// clean-up
CleanupStack::PopAndDestroy(2, &fs);
return aTestCase;
}
//读取存档
void TPlayerInfo::ReadPlayerInfo()
{
RFs oFs;
if (oFs.Connect())
{
return;
};
RFileReadStream oReadStream;
//如果打开失败 将返回一个非0值，则返回
if (oReadStream.Open(oFs, *iFileName, EFileRead))
{
oFs.Close();
return;
}
//
oReadStream.PushL();
TInt32 playerCount;
oReadStream >> playerCount;
for (TInt i = 0; i < playerCount; i++)
{
if (i < AWARD_PLAYER_COUNT)
{
//iPlayerArray[i].InternalizeL(oReadStream);
iPlayerList[i]->InternalizeL(oReadStream);
}
}
oReadStream.Pop();
oReadStream.Release();
oFs.Close();
}
void CTestImpExvCardSuiteStepBase::ImportItemL(TBuf<80> aPath, TBool aImportBDay)
{
RFs fs;
User::LeaveIfError(fs.Connect()); // push fs
CleanupClosePushL(fs);
RFileReadStream readVCFStream;
INFO_PRINTF1(_L("Opening exported vcf file to import, to check REV property"));
User::LeaveIfError(readVCFStream.Open(fs, aPath, EFileRead));
TBuf<MAX_TEXT_MESSAGE> message;
message.Format(KOpenVCFFile, &KExportRevUTCFile);
INFO_PRINTF1(message);
CleanupClosePushL(readVCFStream); // readVCFStream
if (aImportBDay)
{
ImportBDAYCardL(readVCFStream);
}
else
{
ImportCardL(readVCFStream);
}
CleanupStack::PopAndDestroy(); // readVCFStream
CleanupStack::PopAndDestroy(); // pop fs
}
void CheckAndInitializeFileL( RFs& aFs, TBuf<KMaxFileName>& aFile, const TDesC16& aFilePath,
RFileReadStream& aTempFile, CFileMan* aFileMan )
{
__LOG1( ELogAlways, "CheckAndInitializeFileL() - handling file %S", &aFilePath );
const TInt err = aTempFile.Open( aFs, aFile, EFileRead | EFileShareAny );
__LOG1( ELogAlways, "CheckAndInitializeFileL() - open file error %d", err );
aTempFile.Close();
if ( err != KErrNone )
{
if ( err == KErrNotFound )
{
// Path found but not schema.mde, copy schema.m
const TInt error = aFileMan->Copy( aFilePath, aFile, CFileMan::EOverWrite );
__LOG1( ELogAlways, "CheckAndInitializeFileL() - copy file error %d", error );
}
else if ( err == KErrPathNotFound)
{
// Create private dir
User::LeaveIfError( aFs.CreatePrivatePath( EDriveC ) );
// Copy schema.mde
const TInt error = aFileMan->Copy( aFilePath, aFile, CFileMan::EOverWrite );
__LOG1( ELogAlways, "CheckAndInitializeFileL() - copy file error %d", error );
}
}
}
// ---------------------------------------------------------------------------
// Restore the file from given directory and given index
// ---------------------------------------------------------------------------
//
EXPORT_C CXIMPApiEventBase* CXIMPTestFileTool::PluginRestoreLC(
TInt aObjIndex )
{
HBufC* fileName = GetFileNameLC(
KFileToolPluginDirBase,
aObjIndex );
// try to instantiate it
RFileReadStream in;
CleanupClosePushL( in );
in.Open( iFs, *fileName, EFileStream );
TInt len = in.ReadUint32L();
HBufC8* buffer = HBufC8::NewLC( len );
TPtr8 ptr = buffer->Des();
in.ReadL( ptr );
// instantiate the object
TInt32 dummy = 0;
CXIMPApiEventBase* object = XIMPEventCodec::UnPackL( *buffer, dummy );
CleanupStack::PopAndDestroy( 2 ); // buffer, in
// delete the just read object
iFs.Delete( *fileName );
CleanupStack::PopAndDestroy( fileName );
CleanupStack::PushL( object );
return object;
}
// -----------------------------------------------------------------------------
// RDRMRightsClient::URIFileToArrayL
// Converts the given file into an array.
// -----------------------------------------------------------------------------
//
void RDRMRightsClient::URIFileToArrayL( RFs& aFs,
const TDesC& aFile,
RPointerArray< HBufC8 >& aList )
{
DRMLOG( _L( "RDRMRightsClient::URIFileToArrayL" ) );
RFileReadStream stream;
TUint16 size = 0;
TPtr8 data( NULL, 0, 0 );
User::LeaveIfError( stream.Open( aFs, aFile, EFileRead | EFileStream ) );
CleanupClosePushL( stream );
size = stream.ReadUint16L();
while( size > 0 )
{
HBufC8* tmp = HBufC8::NewLC( size );
data.Set( tmp->Des() );
stream.ReadL( data, size );
User::LeaveIfError( aList.Append( tmp ) );
CleanupStack::Pop(); // tmp
size = stream.ReadUint16L();
}
// All read, return.
CleanupStack::PopAndDestroy(); // stream
}
/**
@SYMTestCaseID SYSLIB-STORE-CT-1127
@SYMTestCaseDesc Stream encryption test.
Tests the functionality of REncryptStream and RDecryptStream classes
@SYMTestPriority High
@SYMTestActions Tests for writing an encrypted string to a stream,reading back the data,decrypt and
check with the original data.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ0000
*/
LOCAL_C void testSimpleStreamEncryptionL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1127 "));
CPBEncryptElement* elementKey = CPBEncryptElement::NewL(KTestPassword);
CleanupStack::PushL(elementKey);
TParsePtrC parse(KFileLocationSpec);
RFileWriteStream writeStream;
writeStream.PushL();
User::LeaveIfError(writeStream.Replace(TheFs, parse.NameAndExt(), EFileWrite));
REncryptStream encryptStream;
encryptStream.OpenLC(writeStream, *elementKey);
encryptStream << KTestDes;
encryptStream.CommitL();
writeStream.CommitL();
CleanupStack::PopAndDestroy(2); // encryptStream, writeStream
RFileReadStream readStream;
readStream.PushL();
User::LeaveIfError(readStream.Open(TheFs, parse.NameAndExt(), EFileWrite));
RDecryptStream decryptStream;
decryptStream.OpenLC(readStream, *elementKey);
decryptStream >> TheBuf;
test(KTestDes == TheBuf);
CleanupStack::PopAndDestroy(3, elementKey); // decryptStream, readStream
}
/**
@SYMTestCaseID SYSLIB-SQL-CT-1635
@SYMTestCaseDesc RSqlSecurityPolicy test.
Tests RSqlSecurityPolicy API.
@SYMTestPriority High
@SYMTestActions RSqlSecurityPolicy test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ5792
REQ5793
*/
void SqlSecurityPolicyTest()
{
RSqlSecurityPolicy securityPolicy;
TInt err = securityPolicy.Create(KDefaultPolicy);
TEST2(err, KErrNone);
//Empty RSqlSecurityPolicy object tests
//Database policies
TSecurityPolicy policy = securityPolicy.DbPolicy(RSqlSecurityPolicy::ESchemaPolicy);
TEST(policy == KDefaultPolicy);
policy = securityPolicy.DbPolicy(RSqlSecurityPolicy::EReadPolicy);
TEST(policy == KDefaultPolicy);
policy = securityPolicy.DbPolicy(RSqlSecurityPolicy::EWritePolicy);
TEST(policy == KDefaultPolicy);
//Table policies
policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, _L("A-Tbl"), RSqlSecurityPolicy::EReadPolicy);
TEST(policy == KDefaultPolicy);
policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, _L("B-Tbl"), RSqlSecurityPolicy::EWritePolicy);
TEST(policy == KDefaultPolicy);
//
securityPolicy.Close();
//Tests with initialized RSqlSecurityPolicy object
CreateTestSecurityPolicy(securityPolicy);
//Check the created and initialized object
CheckTestSecurityPolicy(securityPolicy);
//Externalize, then internalize and check the security policy object
RFileWriteStream out;
err = out.Replace(TheFs, KTestFile, EFileRead | EFileWrite);
TEST2(err, KErrNone);
TRAP(err, securityPolicy.ExternalizeL(out));
TEST2(err, KErrNone);
TRAP(err, out.CommitL());
out.Close();
TEST2(err, KErrNone);
securityPolicy.Close();
err = securityPolicy.Create(KDefaultPolicy);
TEST2(err, KErrNone);
RFileReadStream in;
err = in.Open(TheFs, KTestFile, EFileRead);
TEST2(err, KErrNone);
TRAP(err, securityPolicy.InternalizeL(in));
in.Close();
TEST2(err, KErrNone);
CheckTestSecurityPolicy(securityPolicy);
//Change some security policies and check that the RqlSecurityPolicy content was properly updated
err = securityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KTableName11, RSqlSecurityPolicy::EReadPolicy, KPolicy3);
TEST2(err, KErrNone);
policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName1, RSqlSecurityPolicy::EReadPolicy);
TEST(policy == KPolicy3);
policy = securityPolicy.Policy(RSqlSecurityPolicy::ETable, KTableName11, RSqlSecurityPolicy::EWritePolicy);
TEST(policy == KPolicy2);
//
securityPolicy.Close();
}
// Local Functions
void ImportEntriesL(const TDesC& aFileName, RPointerArray<CCalEntry>& aCalEntries)
{
RFileReadStream fileReadStream;
CleanupClosePushL(fileReadStream);
TInt err = fileReadStream.Open(calTestLibrary->FileSession(), aFileName, EFileRead);
calTestLibrary->DataExchangeL().ImportL(KUidVCalendar, fileReadStream, aCalEntries);
CleanupStack::PopAndDestroy(&fileReadStream);
}
/**
Reads data chunk from the file stream.
@return ETrue if the EOF found.
@param aFileReadStream - reference to file stream
@param aPtrLineBuffer - reference to the buffer data read
@param aIsUnicode - flag to check is it Unicode or ASCII file
@param aIgnoreCharList - pointer to ingnore char list
@leave KErrNotFound
*/
TBool TestFrameworkActionsUtils::ReadDataL(RFileReadStream& aFileReadStream,
TPtr& aPtrLineBuffer, TBool aIsUnicode, CArrayFixFlat<TUint16>* aIgnoreCharList)
{
TUint16 element = 0;
TKeyArrayFix key(0, ECmpTUint16);
TInt charPosition = 0;
TBool eof = EFalse;
TInt errorCode = KErrNone;
TUint8 aCharASCII = 0;
aPtrLineBuffer.FillZ();
aPtrLineBuffer.SetLength(0);
// Validate the input ignore char list
if (!aIgnoreCharList)
{
// Invalid parameter passed to ReadDataL: No ignore char list passed
User::Leave(KErrNotFound);
}
// Read data from file and store it in lineBuffer
do
{
if(aIsUnicode)
{
TRAP(errorCode, (element = aFileReadStream.ReadUint16L()));
}
else
{
TRAP(errorCode, (aCharASCII = aFileReadStream.ReadUint8L()));
element = (TUint16) aCharASCII;
}
if (errorCode!=KErrEof)
{
// Check the availability of ignore char in the array
if ( aIgnoreCharList->Find(element, key, charPosition) != KErrNone )
{
// Append the char to the buffer if the read char is not ignore char
aPtrLineBuffer.Append(element);
}
}
else
{
eof = ETrue;
break;
}
// Stop at the end of line or no more data
} while(aPtrLineBuffer.Length()<KDefBufferSize);
// Return end of file flag
return eof;
}
// -----------------------------------------------------------------------------
// RDRMRightsClient::FileToListL
// Converts the given file into an array.
// -----------------------------------------------------------------------------
//
void RDRMRightsClient::FileToListL( RFs& aFs,
const TDesC& aFileName,
RPointerArray< CDRMPermission >& aList )
{
DRMLOG( _L( "RDRMRightsClient::FileToListL" ) );
TInt error = KErrNone;
// Temporary storage.
CDRMPermission* tmpObject;
// To access the file data.
RFileReadStream fileStream;
// How many objects there is in the file.
TInt size = 0;
// Temporary counter.
TInt count = 0;
// Open the file.
User::LeaveIfError( fileStream.Open( aFs, aFileName, EFileRead | EFileStream ) );
CleanupClosePushL( fileStream );
size = fileStream.ReadInt32L();
while( count < size )
{
// Allocate a new RO.
tmpObject = CDRMPermission::NewL();
// Read the object.
TRAP( error, tmpObject->InternalizeL( fileStream ) );
if ( !error )
{
// Add the object into the list.
error = aList.Append( tmpObject );
}
if ( error )
{
delete tmpObject;
User::Leave( error );
}
// Now tmpObject is under responsibility of aList.
++count;
}
// All done.
CleanupStack::PopAndDestroy(); // fileStream
}
void CTransactionsStep::TransactionPerformanceL( const TBool aDelete,
const FieldFullness aField,
const TInt aContacts,
TReal &aDiffseconds,
TReal &aCumseconds)
{
iContacts = ( ( aContacts / KTransactionSize ) + 1 ) * KTransactionSize ;
TInt64 cumlative = 0;
TInt64 diff = 0;
TTime startT;
TTime finishT;
TTime start;
TTime finish;
TInt j = 0;
for(; j < KPerfIter; ++j)
{
CPerformanceFunctionalityBase::InitializeL();
ModifyContactsL(aField);
ExportVcardL( aDelete, KVcardFile );
RFileReadStream rfrs;
CleanupClosePushL( rfrs );
User::LeaveIfError( rfrs.Open( iParent->Fs(), KVcardFile, EFileRead | EFileShareAny ) );
TInt i = 0;
start.UniversalTime();
for(; i < iContacts; i+=KTransactionSize)
{
iContactsDatabase->DatabaseBeginLC(EFalse);
ImportVcardL(KTransactionSize, rfrs);
startT.UniversalTime();
iContactsDatabase->DatabaseCommitLP(EFalse);
finishT.UniversalTime();
cumlative += ( finishT.MicroSecondsFrom( startT ).Int64() );
}
finish.UniversalTime();
diff += ( finish.MicroSecondsFrom(start).Int64() );
CleanupStack::PopAndDestroy(&rfrs);
}
User::LeaveIfError( iParent->Fs().Delete(KVcardFile) );
aDiffseconds = (TReal) diff / (1000000 * KPerfIter);
aCumseconds = (TReal) cumlative / (1000000 * KPerfIter);
_LIT(KMicroPerformance, "Micro performance: %d");
_LIT(KSecondsPerformance, "performance in seconds: %f");
_LIT(KCommitPerformance, "commit performance in seconds: %f");
ALLPRINT2(KMicroPerformance, diff);
ALLPRINT2(KSecondsPerformance, aDiffseconds );
ALLPRINT2(KCommitPerformance, aCumseconds );
}
// -----------------------------------------------------------------------------
// CBSBrandHandler::VerifyVersionL()
// -----------------------------------------------------------------------------
//
void CBSBrandHandler::VerifyVersionL()
{
if( !iHandle )
{
User::Leave( KErrNotReady );
}
RFileReadStream stream;
stream.Attach( *iHandle );
CleanupClosePushL( stream );
VerifyVersionL( stream );
CleanupStack::PopAndDestroy(); // stream
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRequestManager::ReadConfigInfoL()
{
FLOG(_L("[IMAGEPRINTUI]\t CRequestManager::ReadConfogInfoL Sstart"));
RFileReadStream readStream;
User::LeaveIfError( readStream.Open(CCoeEnv::Static()->FsSession(),
iCongFileName->Des(), EFileRead) );
readStream.PushL();
readStream >> iVendorName;
readStream >> iProductName;
CleanupStack::PopAndDestroy(&readStream);
FLOG(_L("[IMAGEPRINTUI]\t CRequestManager::ReadConfogInfoL end"));
}
TBool CSyntaxTest::LoadResultsL()
{
RFile resultsFile;
TFileName fullPath;
TInt err, fileSize;
HBufC8 *fileInfo;
fullPath.Append(iPath);
fullPath.Append(KResultsFile);
err = resultsFile.Open(iFs, fullPath, EFileRead);
if (err != KErrNone)
{
iConsole.Printf(_L("Error opening results file : "));
iConsole.Printf(fullPath);
iConsole.Printf(_L("\n"));
return(EFalse);
}
CleanupClosePushL(resultsFile);
resultsFile.Size(fileSize);
CleanupStack::PopAndDestroy(); // resultsFile
fileInfo = HBufC8::NewLC(fileSize);
TPtr8 fileInfoPtr(fileInfo->Des());
fileInfoPtr.SetLength(fileSize);
RFileReadStream fileStream;
User::LeaveIfError(fileStream.Open(iFs, fullPath, EFileStream));
CleanupClosePushL(fileStream);
fileStream.ReadL(fileInfoPtr, fileSize);
TLex8 theLex(fileInfoPtr);
CSyntaxResult *syntaxResult = NULL;
do
{
syntaxResult = CSyntaxResult::NewLC();
syntaxResult->SetFilename(theLex.NextToken());
syntaxResult->SetResult(theLex.NextToken());
iExpectedResults->Append(syntaxResult);
CleanupStack::Pop(); // syntaxResult
}
while(!theLex.Eos());
CleanupStack::PopAndDestroy(2); // fileinfo & fileStream
return(ETrue);
};
/**
Overload of the CCoeAppUi virtual method.
The method in the base class merely returns ETrue. Overloads would normally just return EFalse.
In this case however, we do some jiggery-pokery in order to invoke the StartSafe retry mechanism.
ie we return EFalse on each of several invocations but don't do the Rendezvous, then
eventually ETrue, so the Framework Rendezvous for us. our final invocation therefore being successful.
The count file is written from the test-step, and
if successful, deleted here.
The code is nearly all parenthesised within a TRAP harness in order to preserve the integrity
of this function, which is called by the framework.
*/
TBool CTestAppUi::FrameworkCallsRendezvous() const
{
TBool frameworkRendezvous = EFalse;
TRAPD( err,
{
RFs fs;
RFileReadStream readStream;
RFileWriteStream writeStream;
CleanupClosePushL( fs );
CleanupClosePushL( readStream );
CleanupClosePushL( writeStream );
if( KErrNone != fs.Connect()
|| KErrNone != readStream.Open(fs, KDontRvCountFile, EFileRead) )
{
User::Leave( KErrCouldNotConnect );
}
TInt failCount = readStream.ReadInt8L();
readStream.Close();
if( 0 == failCount )
{
fs.Delete( KDontRvCountFile );
// We've decided to be good this time. Let the framework do it for us.
frameworkRendezvous = ETrue;
}
else
{
// StartSafe will timeout while waiting for a Rendezvous()
User::LeaveIfError( writeStream.Open(fs, KDontRvCountFile, EFileWrite) );
writeStream.WriteInt8L( --failCount );
writeStream.CommitL();
writeStream.Close();
}
CleanupStack::PopAndDestroy( 3, &fs );
} );
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
}
// -----------------------------------------------------------------------------
// CBSBrandHandler::VerifyVersionL()
// -----------------------------------------------------------------------------
//
void CBSBrandHandler::VerifyVersionL( RFileReadStream& aStream )
{
TInt version = aStream.ReadInt16L();
if( version != iReserved )
{
User::Leave( KErrArgument );
}
}
void CEmTubePlaylistEntry::ImportL( RFileReadStream& aStream )
{
TInt l = aStream.ReadInt32L();
if( l )
{
iLocation = HBufC::NewL( l );
TPtr pLocation( iLocation->Des() );
aStream.ReadL( pLocation, l );
}
else
{
iLocation = KNullDesC().AllocL();
}
l = aStream.ReadInt32L();
if( l )
{
iName = HBufC::NewL( l );
TPtr pName( iName->Des() );
aStream.ReadL( pName, l );
}
else
{
iName = KNullDesC().AllocL();
}
iPlayCount = aStream.ReadInt32L();
iType = (TEmTubePlaylistEntryType)aStream.ReadInt32L();
TReal t = aStream.ReadReal64L();
iTime = TTime( Int64( t ) );
}
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;
}
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;
}
