void CFileOperator::DoWriteL()
{
RFile file;
TInt count = iFirstFile;
_LIT8(KData, "Some text for writing test of enhanced notification performance test.");
while (count < iFirstFile + iNumFiles)
{
TFileName nextFile;
FileNameGen(nextFile, count);
file.Open(iFs, nextFile, EFileWrite);
file.Write(KData);
// Flush file to ensure notification is received
file.Flush();
file.Close();
count++;
}
}
void CFileOperator::DoManyChangesOnSingleFileL()
{
TFileName fileName;
FileNameGen(fileName, 9999);
RFile file;
_LIT8(KData, "a");
for(TInt i = 0; i < iNumFiles; i++)
{
TInt offset = 0;
file.Open(iFs, fileName, EFileWrite);
file.Seek(ESeekEnd, offset);
file.Write(KData);
file.Flush();
file.Close();
}
}
void CIoReadTest::ReadFileL()
{
RFile file;
LeaveIfErr(file.Open(Fs(), iFile, EFileRead | EFileShareExclusive), _L("Cannot open file '%S'"), &iFile);
CleanupClosePushL(file);
TInt fileSize;
User::LeaveIfError(file.Size(fileSize));
RBuf8 contents;
contents.CreateL(fileSize);
CleanupClosePushL(contents);
User::LeaveIfError(file.Read(contents));
// convert data to 16-bit which is how it'll come out of the io server
iFileContents.CreateL(fileSize);
iFileContents.Copy(contents); // copy & expand
CleanupStack::PopAndDestroy(2, &file); // contents, file
}
void FileDependencyUtil::CheckFileDependencyL()
{
RFs fsSession;
RFile file;
CleanupClosePushL(fsSession);
User::LeaveIfError(fsSession.Connect());
TInt err = file.Open(fsSession, KSoundDevBtFileName, EFileRead);
file.Close();
if(err != KErrNone)
{
User::LeaveIfError(KErrNotSupported);
}
CleanupStack::PopAndDestroy(); //fsSession
}
HBufC* TestUniDataModelVCalPlugin::ReadFromFileL(const TDesC& aFile)
{
RFile file;
TBuf8<1024> lineBuffer;
TInt err = KErrNone;
err = file.Open(iFs, aFile, EFileStreamText | EFileRead | EFileShareAny);
if (err != KErrNone) // Didn't find the file, so leave - should only get valid filenames!
{
User::Leave(KErrNotFound);
}
HBufC* bioBuf = HBufC::NewLC(65535); // Create a new descriptor on the heap.
HBufC* copyBuffer = HBufC::NewLC(1024);
do // Read in the text from file, and also check if there is a name field:
{
err = file.Read(lineBuffer);// Read upto 256 chars, '\n' and all...
//err = ReadLineL(file,lineBuffer);
if (err == KErrNone) // Made a valid read,
if (lineBuffer.Length() == 0) // but read 0 chars
err = KErrEof; // so set err value to end processing
if (err == KErrNone)
{
copyBuffer->Des().Copy(lineBuffer);// Copy, and overwrite existing text
if ( (bioBuf->Length() + copyBuffer->Length())
> bioBuf->Des().MaxLength())
{
bioBuf = bioBuf->ReAllocL(bioBuf->Length()
+ copyBuffer->Length());
}
bioBuf->Des().Append(*copyBuffer);
//bioBuf->Des().Append(_L("\n"));
}
}while (err != KErrEof);
CleanupStack::PopAndDestroy(); // Destroy the copyBuffer.
CleanupStack::Pop();// Remove the bioBuf.
file.Close();
return bioBuf;
}
/**
* Creates a file and copies the data in the source file to the destination file.
*/
TInt RTestStepOggCtrlBase::CopyFile(TPtrC aFileNameSrc, TPtrC aFileNameDst)
{
TInt theErr = KErrNone;
RFs fs;
fs.Connect();
RFile theFileNew;
RFile theFile;
fs.MkDirAll(aFileNameDst);
theFile.Open(fs, aFileNameSrc, EFileShareReadersOnly);
TInt theSize;
theFile.Size(theSize);
TBuf8<KSizeBuf> theBuf;
TInt theStep = KSizeBuf;
if(theStep > theSize)
{
theStep = theSize;
}
TInt theRes = theFileNew.Create(fs, aFileNameDst, EFileShareAny);
if(theRes == KErrAlreadyExists)
{
theRes = theFileNew.Replace(fs, aFileNameDst, EFileShareAny);
}
if(theRes != KErrNone)
{
return theRes;
}
TInt theCurLength = 0;
while(theCurLength < theSize)
{
theFile.Read(theBuf, theStep);
theFileNew.Write(theBuf, theStep);
theCurLength += theStep;
if(theCurLength + theStep > theSize )
{
theStep = theSize - theCurLength;
}
}
theFileNew.Close();
theFile.Close();
fs.Close();
return theErr;
}
// ---------------------------------------------------------
// CBrCtlSampleAppLinkResolver::ReadFile
// ---------------------------------------------------------
//
HBufC8*
CBrCtlSampleAppLinkResolver::ReadFileLC(const TDesC& aFileName)
{
RFs rfs;
RFile file;
User::LeaveIfError(rfs.Connect());
CleanupClosePushL(rfs);
User::LeaveIfError(file.Open(rfs, aFileName, EFileRead));
CleanupClosePushL(file);
TInt size;
User::LeaveIfError(file.Size(size));
HBufC8* buf = HBufC8::NewLC(size);
TPtr8 bufPtr(buf->Des());
User::LeaveIfError(file.Read(bufPtr));
CleanupStack::Pop(); // buf
CleanupStack::PopAndDestroy(2); // file, rfs
CleanupStack::PushL(buf);
return buf;
}
void CLinePaginatorTest::OpenTestFileL()
{
TBuf8<128> text;
TInt err=ifsClient.Connect();
err=iTestFile.Open(ifsClient,TEST_FILE,EFileStream|EFileRead|EFileShareReadersOnly);
iTestFile.Read(0,text,128);
TInt startNum=text.Locate('<')+1;
text.Delete(0,startNum);
TLex8 lex=text;
TInt pageHeight;
lex.Val(pageHeight);
iPaginator.SetPageHeight(pageHeight);
TBuf<254> buf;
buf.AppendFormat(_L("DocPos\tHeight\tKeep\tStart\tHeight of Pages = <%d>\n"), pageHeight);
TESTPRINT(buf);
}
// -----------------------------------------------------------------------------
// AddDomainRoL()
// The function will add a file info into database
// -----------------------------------------------------------------------------
//
void CDcfRepSrv::AddDomainRoL( const TDesC& aFile )
{
#ifdef _DRM_TESTING
WriteL(_L8("AddDomainRoL"));
#endif
__UHEAP_MARK;
RFile file;
TPtr8 ptr(NULL,0,0);
CContent* content =NULL;
User::LeaveIfError(file.Open(iFs, aFile, EFileShareReadersOrWriters | EFileWrite ) );
CleanupClosePushL(file);
content = CContent::NewL(file);
CleanupStack::PushL(content);
User::LeaveIfError(content->AgentSpecificCommand(EEmbedDomainRo,
KNullDesC8, ptr ));
CleanupStack::PopAndDestroy(2); // content, file
__UHEAP_MARKEND;
}
void CTFXConfigParser::ParseL(const TDesC& aFilename)
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFile file;
User::LeaveIfError(file.Open(fs, aFilename, EFileRead | EFileShareReadersOnly));
CleanupClosePushL(file);
TInt filesize = 0;
User::LeaveIfError(file.Size(filesize));
HBufC8* buffer = HBufC8::NewLC(filesize);
TPtr8 ptr( buffer->Des() );
User::LeaveIfError(file.Read(ptr, filesize));
iParser->ParseBeginL();
iParser->ParseL(*buffer);
iParser->ParseEndL();
CleanupStack::PopAndDestroy(3); // fs, file, buffer
}
TInt CFloggerTest025_BuildTestUrel3::DoTestCheckWriteL()
{
RFile theFile;
HBufC8 * hBuffer;
TInt listfilesize;
TInt returnCode;
RFs fileSystem; //For file operation create a file system
TInt numSuccessful = 0;
User::After(KTimeToLog);
User::LeaveIfError(fileSystem.Connect());
//Open the file in the read mode
User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
CleanupClosePushL(theFile);
User::LeaveIfError(returnCode = theFile.Size(listfilesize)); //Size of the file
hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
CleanupStack::PushL(hBuffer);
TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
// Read from position 0: start of file
returnCode = theFile.Read(ptrString);
// we should not find any log string
if (returnCode == KErrNone)
{
returnCode = ptrString.Find(KTestMessage8);
if (returnCode == KErrNotFound)
{
numSuccessful++;
}
}
CleanupStack::PopAndDestroy(hBuffer);
CleanupStack::PopAndDestroy(); // For theFile object
if (numSuccessful > 0)
return KErrNone;
else
return KErrGeneral;
}
void CCntPBAPSupport::CompareExportsL(const TDesC8& aExpected)
{
RFile exportedFile;
TInt err = exportedFile.Open(iFsSession, KTempExportFile(), EFileRead);
if (err != KErrNone)
{
ReportFileErrorL(err, KTempExportFile());
}
CleanupClosePushL(exportedFile);
RFileReadStream stream1(exportedFile);
CleanupClosePushL(stream1);
TBuf8<0x80> bufO;
TInt line = 1;
do {
TRAP(err, stream1.ReadL(bufO, TChar(0xa)));
if (err != KErrNone && err != KErrEof)
{
User::Leave(err);
}
_LIT8(KPropREV,"REV:");
_LIT8(KPropUID,"UID:");
TBufC8<4> first4char(bufO.Left(4));
if(!first4char.Compare(KPropREV()) || !first4char.Compare(KPropUID()))
{
continue;
}
if (KErrNotFound == aExpected.Find(bufO))
{
TBuf<256> info;
info.Copy(bufO);
TRefByValue<const TDesC> format(info);
test.Printf(format);
test (EFalse);
}
++line;
} while (err != KErrEof);
CleanupStack::PopAndDestroy(2,&exportedFile);
}
/**
@SYMTestCaseID SYSLIB-XML-CT-3748
@SYMTestCaseDesc Processing namespaces.
@SYMTestPriority Medium
@SYMTestActions Creating an xml parser and enabling namespace mapping reporting, before parsing a document.
@SYMTestExpectedResults The document is parsed with the namespace mapping reporting enabled.
@SYMDEF INC059062
*/
LOCAL_C void INC059062L()
{
RDefectTests handler;
CleanupClosePushL (handler);
CParser* parser = CParser::NewLC(KXmlParserDataType, handler);
User::LeaveIfError(parser->EnableFeature(EReportNamespaceMapping));
RFile handle;
handle.Open(TheFs, KNsAndBindingFile, EFileShareReadersOnly);
CleanupClosePushL (handle);
ParseL(*parser, handle);
CleanupStack::PopAndDestroy (&handle);
CleanupStack::PopAndDestroy (parser);
CleanupStack::PopAndDestroy (&handler);
}
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;
}
TBool TestExportedFile(const TDesC& aFilename)
{
//Check for DTSTART and DTEND
//Check it is in DATE-TIME format
TBool DTSTART_patternFound = EFalse;
TBool DTEND_patternFound = EFalse;
RFile fileHandle;
CleanupClosePushL(fileHandle);
fileHandle.Open(calTestLibrary->FileSession(),aFilename, 0);
TBuf8<256> line;
TInt KDateLength = 8;
TInt KColon = 1;
while (fileHandle.Read(line) == KErrNone && line.Length() != 0)
{
TInt pos = line.Find(KDTSTART());
if (pos != KErrNotFound)
{
DTSTART_patternFound = ETrue;
TText time;
time = line[pos + KDTSTART().Length() + KColon + KDateLength ];
test (time == 'T');
}
pos = line.Find(KDTEND());
if ( pos != KErrNotFound)
{
DTEND_patternFound = ETrue;
TText time;
time = line[pos + KDTEND().Length() + KColon + KDateLength ];
test (time == 'T');
if (DTSTART_patternFound && DTEND_patternFound)
break;
}
}
CleanupStack::PopAndDestroy(&fileHandle);
return (DTSTART_patternFound && DTEND_patternFound);
}
void CRuleManager::ReadFavFromFile()
{
TFileName filename;
GetAppPath(filename);
filename.Append(KFavRuleFile);
RFile file;
TInt err;
err = file.Open(CCoeEnv::Static()->FsSession(), filename, EFileRead);
CleanupClosePushL(file);
if (KErrNone != err)
{
CleanupStack::PopAndDestroy(); // file
return;
}
TInt size;
file.Size(size);
if (size > 0)
{
HBufC8* text = HBufC8::NewL(size);
TPtr8 ptr = text->Des();
file.Read(ptr);
TInt pos = ptr.Locate(KCharRuleSymbolEnd);
if (pos != KErrNotFound)
{
ReadFromFile(ptr,pos,iFavRule);
ptr.Delete(0,pos+1);
TInt num = CCommonUtils::StrToInt(ptr);
iFavRule->SetFavCount(num);
}
delete text;
}
CleanupStack::PopAndDestroy(); // file
}
//********************************************************************************************
CParserVCard* CVersitCardTest::InternalizeCardLC(const TDesC& aFile)
//
// Internalize the specified file
//
{
CParserVCard* parser = CParserVCard::NewL();
CleanupStack::PushL(parser);
//
TInt pos = 0;
RFile file;
User::LeaveIfError(file.Open(TheFsSession, aFile, EFileRead));
CleanupClosePushL(file);
// Read from the file
static_cast<CVersitParser*>(parser)->InternalizeL(file, pos);
CleanupStack::PopAndDestroy(); // file
//
return parser;
}
//test for Reccurrence rule in VCal (VCS)
void CTestVersitObserver::TestReccurrenceRulesL()
{
RFile file;
_LIT(KFileI,"Z:\\TestFiles\\IRDailyVCal.VCS");
CParserVCal* parser=CParserVCal::NewL();
CleanupStack::PushL(parser);
User::LeaveIfError(file.Open(iFs, KFileI, EFileRead));
CleanupClosePushL(file);
TInt start=0;
parser->CVersitParser::InternalizeL(file,start);
CleanupStack::Pop(&file);
file.Close();
CArrayPtr<CVersitParser>* entities= parser->ArrayOfEntities(EFalse);
CArrayPtr<CParserProperty>* properties = (*entities)[0]->PropertyL(KVersitTokenRRULE, TUid::Uid(KVCalPropertyRecurrenceUid), EFalse); // don't take ownership
CleanupStack::PushL(properties);
CParserPropertyValueRecurrence* propertyrecurval = (CParserPropertyValueRecurrence*)((*properties)[0]->Value());
TheTest(2 == (propertyrecurval->Value())->iDuration);
CleanupStack::PopAndDestroy(properties);
CleanupStack::PopAndDestroy(parser);
}
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;
}
// -----------------------------------------------------------------------------
// CWidgetUiObserver::ReadFile
// -----------------------------------------------------------------------------
//
HBufC8* CWidgetUiObserver::ReadFileL( const TDesC& aFileName )
{
RFile file;
if (KErrNone != file.Open( CCoeEnv::Static()->FsSession(), aFileName, EFileRead ) )
{
return NULL;
}
CleanupClosePushL( file );
TInt size;
User::LeaveIfError( file.Size( size ) );
HBufC8* buf = HBufC8::NewLC( size );
TPtr8 bufPtr( buf->Des() );
User::LeaveIfError( file.Read( bufPtr ) );
CleanupStack::Pop( buf );
CleanupStack::PopAndDestroy( &file );
return buf;
}
/**
* Read File
*
* @param aFileName File name to read
* @param aBuf Buffer to read file content
*
* @return N/A
*
* @leave System wide error
*/
void CT_DataVerify::ReadFileL(const TFileName& aFileName, TDes8& aBuf)
{
RFile file;
User::LeaveIfError( file.Open( iFs, aFileName, EFileRead ) );
CleanupClosePushL( file );
// Get the file size
TInt size;
User::LeaveIfError( file.Size( size ) );
// allocate memory from heap for file content
HBufC8* buf = HBufC8::NewLC( size );
aBuf = buf->Des();
// read file content into buffer, file may be too big for HBufC8
User::LeaveIfError( file.Read( aBuf ) );
CleanupStack::Pop( buf );
CleanupStack::PopAndDestroy( &file ); // file.Close
}
TInt CFileOperate::ReadFileL(const TDesC& aFileName)
{
RFile file;
TInt err = file.Open(CCoeEnv::Static()->FsSession(), aFileName, EFileRead);
CleanupClosePushL(file);
if (KErrNone != err)
{
CleanupStack::PopAndDestroy(1); // file
return err;
}
//²Ù×÷
RFileReadStream stream(file);
CleanupClosePushL(stream);
iNotifier->FileReadData(stream);
CleanupStack::PopAndDestroy(2);
return KErrNone;
}
void CStorageManager::WriteToDiskL(TFileName& aFile, const TDesC8& aData)
/**
Writes data to disk
@param aFile - file to write to
@param aData - data to write
*/
{
RFile file;
// Place on the cleanup stack:
CleanupClosePushL(file);
TInt error = iTestStep->Fs().MkDirAll(aFile);
if (error == KErrAlreadyExists || error == KErrNone) // directory exists
{
if (iLastFile == aFile) // more data needs appended to already open file
{
error = file.Open(iTestStep->Fs(), aFile, EFileWrite);
}
else
{
error = file.Replace(iTestStep->Fs(), aFile, EFileWrite);
}
}
if (error != KErrNone)
{
CleanupStack::PopAndDestroy(&file); // file
User::Leave(error) ;
}
TInt size = NULL;
file.Size(size);
error = file.Write(size, aData);
file.Flush();
iLastFile = aFile;
CleanupStack::PopAndDestroy(&file); // file
User::LeaveIfError(error);
}
/**
Checks if message is logged in the log file.
@param aMsg The message to be checked.
@return ETrue if the message is found in the log file, otherwise EFalse.
*/
TInt CT_WServGenericpluginStepLoad::CheckLogL(TDesC8& aMsg)
{
RFs fs;
CleanupClosePushL(fs);
User::LeaveIfError(fs.Connect());
RFile logFile;
CleanupClosePushL(logFile);
TInt ret = logFile.Open(fs, KLogFileName, EFileShareAny|EFileRead);
if (ret == KErrNone)
{
TInt fileSize;
User::LeaveIfError(logFile.Size(fileSize));
HBufC8* buf = HBufC8::NewLC(fileSize);
TPtr8 ptr(buf->Des());
ret = logFile.Read(ptr);
if (ret == KErrNone)
{
ret = ptr.Find(aMsg);
if (ret != KErrNotFound)
{
ret = EMsgFound;
}
else
{
ret = EMsgNotFound;
}
}
CleanupStack::PopAndDestroy(buf);
}
else if (ret == KErrNotFound)
{
ret = EFileNotExist;
ERR_PRINTF1(_L("The log file of test plug-ins was not found."));
}
CleanupStack::PopAndDestroy(&logFile);
CleanupStack::PopAndDestroy(&fs);
return ret;
}
void CLogCompressor::WriteBufL(const TDesC8& /*aBuf*/)
{
TDes& filename = iServer.GetFilenameToRotate();
HBufC* compressedFile = HBufC::NewLC(filename.Length()+3);
_LIT(KFmt, "%S.gz");
compressedFile->Des().Format(KFmt, &filename);
RFile input;
//_LIT(KInfo,"Compressing file %S to %S\n");
//console->Printf(KInfo,&inputFile,compressedFile);
User::LeaveIfError(input.Open(iFs, filename, EFileStream | EFileRead | EFileShareAny));
CleanupClosePushL(input);
TRAPD(err, DoGzipL(input, *compressedFile));
if (err)
{
// If the compress failed, delete any fragment (don't care if this fails)
iFs.Delete(*compressedFile);
}
//_LIT(KHoorah,"Hoorah");
//console->Printf(KHoorah);
CleanupStack::PopAndDestroy(&input);
if (err == KErrNone)
{
// Don't delete the original unless the compress succeeded!
err = iFs.Delete(filename);
}
if (err == KErrNone)
{
// We've sucessfully compressed our file, so update filename to reflect that
filename = *compressedFile;
}
// Don't do anything if the delete fails - the file(s) will be cleaned up when the max number of rotated logs is exceeded
CleanupStack::PopAndDestroy(compressedFile);
}
TInt CFloggerTest012_02::DoTestCheckWriteL()
{
User::After(KTimeToLog);
RFile theFile;
HBufC8 * hBuffer;
TInt listfilesize;
TInt returnCode;
RFs fileSystem; //For file operation create a file system
TBuf8<256> testData; //To hold the test descriptor
_LIT(KLogFile, "c:\\logs\\log.txt"); // log file name and path
_LIT8(KTestMessageTwo,"TEST 12.02: The value of first test integer variable :%d The value of second test integer variable : %d");
testData.Format(KTestMessageTwo,100, 200);
User::LeaveIfError(fileSystem.Connect());
//Open the file in the read mode
User::LeaveIfError(theFile.Open(fileSystem,KLogFile,EFileRead));
returnCode = theFile.Size(listfilesize); //Size of the file
hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
CleanupStack::PushL(hBuffer);
TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
// Read from position 0: start of file
returnCode = theFile.Read(ptrString);
returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
//from the file
theFile.Close();
fileSystem.Close();
CleanupStack::PopAndDestroy(hBuffer);
if (returnCode > 0)
return KErrNone;
else
return KErrGeneral;
}
/** Read File in blocks of size aBlockSize
@param fs RFs object
@param aFile File name
@param aBlockSize Size of the blocks to be used in bytes
@param aState Determines if the operation is being done in the main process
or in a thread
@return Returns KErrNone if everything ok, otherwise it panics
*/
TInt ReadFile(RFs& fs, TDes16& aFile, TInt aBlockSize, TTestState aState)
{
RTest test(_L("T_FSCHED"));
TInt r = 0, size = 0;
RFile fileRead;
TEST(aBlockSize > 0);
r = fileRead.Open(fs, aFile, EFileShareAny|EFileRead|EFileReadDirectIO);
TESTERROR(r);
r = fileRead.Size(size);
TESTERROR(r);
if(aState == EThreadWait)
{
gSync.Wait();
User::After(gTimeTakenBigBlock);
}
TInt j = 0;
while(j < size)
{
if((j == 0)&&(aState == EThreadSignal))
{
gSync.Signal();
}
r = fileRead.Read(gBufReadPtr, aBlockSize);
TESTERROR(r);
r = VerifyBuffer(gBufReadPtr, 'B');
TESTERROR(r);
j += aBlockSize;
r = fileRead.Size(size);
TESTERROR(r);
}
fileRead.Close();
return KErrNone;
}
TInt CDataConsumerMemory::SaveData( const TDesC &filePath )
{
TInt err = KErrNone;
RFs FsSession;
err = FsSession.Connect( );
if( err == KErrNone )
{
iLock.Wait( );
{
RFile file;
TInt shareMode = EFileWrite | EFileStream | EFileShareExclusive;
err = file.Open( FsSession, filePath, shareMode );
if( err == KErrNotFound )
{
err = file.Create( FsSession, filePath, shareMode );
}
if( err == KErrNone )
{
if( NULL != iDataBuffer )
{
err = file.Write( iDataBuffer->Des( ) );
}
file.Flush( );
file.Close( );
}
iLock.Signal( );
}
FsSession.Close( );
}
return ( err );
}
// -----------------------------------------------------------------------------
// 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
}
// ---------------------------------------------------------
// CPosTp148::TraceL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp148::TraceL(const TDesC& msg)
{
_LIT8( KEnd, "\r\n" );
RFile file;
TInt err = file.Open(iFileSession, KFileTrace, EFileWrite);
if (err == KErrNotFound)
{
file.Create(iFileSession, KFileTrace, EFileWrite);
}
HBufC8* line8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( msg );
TInt pos( 0 );
file.Seek( ESeekEnd, pos );
file.Write( *line8 );
file.Write( KEnd );
file.Close();
delete line8;
}