void CIniFileParser::DoParseIniFileL(TDesC& aIniFile)
/*
*
* The force flush state is only updated if it is not already set to something other
* than ENoValue. If force flush option is not found in ini file, force flush is set
* to off.
*/
{
TInt fileLength;
TInt ret = KErrNone;
RFile iniFile;
// Open file
User::LeaveIfError(iniFile.Open(iFs, aIniFile, EFileShareAny));
CleanupClosePushL(iniFile);
// as we have been able to open the file, set the media to default.
// If the ini file is parsed correctly, this then gets overwritten.
// Otherwise the caller should pass thru a mesg to get the default enabled.
if (iLoggingMediaString.Length() == 0)
{
iLoggingMediaString = KDefaultMedia;
}
User::LeaveIfError(iniFile.Size(fileLength));
HBufC8* iniContents = HBufC8::NewLC(fileLength);
TPtr8 hbufPtr = iniContents->Des();
User::LeaveIfError(iniFile.Read(hbufPtr));
TLex8 lex(*iniContents);
//OK, file is open and ready for parsing. Make a tempory array and if there is a
//problem in the ini file leave settings as they were, leave, and
//the error will get picked up.
delete iIniSettings;
iIniSettings = NULL;
CIniLoggingPairs* iniSettings = CIniLoggingPairs::NewL();
CleanupStack::PushL(iniSettings);
TNameTag tempTag;
TNameTag tempTag2;
TChar tempChar;
FOREVER
{
ret = GetNextTokenAndCheck(lex,hbufPtr);
if (ret != KErrNone)
{
break;
}
if (hbufPtr.Find(KCommentKeyword)!=KErrNotFound) //found a Comment
{
tempChar = lex.Get();
while (!lex.Eos() && TUint(tempChar) != KCarriageReturn && TUint(tempChar) != KLineFeed)
{
tempChar = lex.Get();
}
}
else if (hbufPtr.CompareF(KMediaKeyword)==0) //MediaSetting
{
User::LeaveIfError(GetNextTokenAndCheck(lex,hbufPtr));
if (hbufPtr.Length()>KMaxMediaStringLength)
{
User::Leave(KErrGeneral);
}
iLoggingMediaString = hbufPtr;
}
else if (hbufPtr.CompareF(KLogKeyword)==0) //LOG
{
User::LeaveIfError(GetNextTokenAndCheck(lex,hbufPtr));
if (hbufPtr.Length()>KMaxTagLength)
{
tempTag = hbufPtr.Left(KMaxTagLength);
}
else
{
tempTag = hbufPtr;
}
User::LeaveIfError(GetNextTokenAndCheck(lex,hbufPtr));
if (hbufPtr.Length()>KMaxTagLength)
{
tempTag2 = hbufPtr.Left(KMaxTagLength);
}
else
{
tempTag2 = hbufPtr;
}
iniSettings->AddSettingL(tempTag, tempTag2);
}
else if (hbufPtr.CompareF(KForceFlushKeyword)==0) //ForceFlush
{
if (iForceFlushState == ENoValue)
{
iForceFlushState = EFlushOn;
}
}
else if (hbufPtr.CompareF(KLogPathKeyword) == 0) //LogPath
{
User::LeaveIfError(GetNextTokenAndCheck(lex,hbufPtr));
if (hbufPtr.Length()>KMaxName)
{
User::Leave(KErrOverflow);
}
iLoggingPathString.Copy(hbufPtr);
}
else if (hbufPtr.CompareF(KWin32DbgPortKeyword)==0) //Win32DebugPort
{
iWin32DebugEnabled = ETrue;
}
else
User::Leave(KErrBadName);
if (lex.Eos())
{
break;
}
}
iIniSettings = iniSettings;
CleanupStack::Pop(iniSettings);
CleanupStack::PopAndDestroy(); //iniContents
CleanupStack::PopAndDestroy(); //iniFile
if (iForceFlushState == ENoValue)
{
iForceFlushState = EFlushOff;
}
}
// -----------------------------------------------------------------------------
// CLibxml2Tester::TestUseExternalDataL
// test deserialize from file, using external data
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CLibxml2Tester::TestUseExternalDataInfosetL(CStifItemParser& aItem)
{
TInt err;
TPtrC pDeserializerType;
aItem.GetNextString( pDeserializerType );
TPtrC pInputFile;
aItem.GetNextString( pInputFile );
TPtrC pBinary;
aItem.GetNextString( pBinary );
TPtrC pFile;
aItem.GetNextString(pFile);
TPtrC pOutputFile;
aItem.GetNextString( pOutputFile );
TPtrC pDirtyReturn;
aItem.GetNextString( pDirtyReturn );
TLex inputNum (pDirtyReturn);
TInt dirtyReturn;
inputNum.Val(dirtyReturn);
TInt nContainers = 3;
RFile fileHandle;
RFs aRFs;
aRFs.Connect();
CleanupClosePushL( aRFs );
SetupDocumentL();
HBufC8* binbuf = ReadFileToBufferL(pBinary);
CleanupStack::PushL(binbuf);
TBufC<100> chunkName(_L("ChunkContainer") );
TInt size = 2000;
TInt maxSize = 10000;
TInt offset = 0;
TInt binarySize = CID_2().Length();
// TBool isReadOnly = EFalse;
RChunk chunk;
chunk.CreateGlobal(chunkName, size, maxSize);
CleanupClosePushL(chunk);
RFile fp;
User::LeaveIfError( fp.Open(aRFs, pFile, EFileRead) );
CleanupClosePushL(fp);
TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), binbuf->Des());
TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);
TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);
iDoc.DocumentElement().AppendChildL(bincont);
iDoc.DocumentElement().AppendChildL(chunkcont);
iDoc.DocumentElement().AppendChildL(filecont);
User::LeaveIfError( fileHandle.Replace( aRFs, pOutputFile, EFileStream | EFileWrite | EFileShareExclusive));
CleanupClosePushL( fileHandle );
CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );
RArray<TXmlEngDataContainer> list;
CleanupClosePushL(list); ////
iDoc.GetDataContainerList(list);
CXmlEngDeserializer* des;
if( pDeserializerType.FindF( XOP ) != KErrNotFound )
{
des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOP );
CleanupStack::PushL( des );
des->SetInputFileL( pInputFile );
des->UseExternalDataL( list );
TRAP(err,des->DeserializeL());
}
else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )
{
des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOPInfoset );
CleanupStack::PushL( des );
des->SetInputFileL( pInputFile );
des->UseExternalDataL( list );
TRAP(err,des->DeserializeL());
}
if(list.Count() != nContainers) User::Leave(KErrGeneral);
CleanupStack::PopAndDestroy( 8 );
if ( err == dirtyReturn ) return KErrNone;
else return err;
}
/**
* Load and initialise an audio file.
*/
TVerdict CTestMmfVclntOpenFile0522::DoTestStepL()
{
TVerdict ret = EFail;
INFO_PRINTF1(_L("Test : Video Recorder - OpenFileL(RFile&)"));
RFs fs;
RFile file;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
User::LeaveIfError(fs.ShareProtected());
iError = KErrTimedOut;
TPtrC filename;
if(!GetStringFromConfig(iSectName,iKeyName,filename))
{
return EInconclusive;
}
User::LeaveIfError(file.Open(fs,filename,EFileWrite));
CleanupClosePushL(file);
CVideoRecorderUtility* rec = CVideoRecorderUtility::NewL(*this);
CleanupStack::PushL(rec);
const TUid KVidTstControllerUid = {KMmfVideoTestControllerUid};
TRAP(iError,rec->OpenFileL(file, NULL, KVidTstControllerUid, KUidMdaBmpClipFormat));
if(iError == KErrNone)
{
INFO_PRINTF1(_L("CVideoRecorderUtility: Open file"));
// Wait for initialisation callback
CActiveScheduler::Start();
}
if(iError == KErrNotSupported)
{
ret = EPass;
}
// Check for errors.
if ((iError == KErrNone) && (rec != NULL))
{
rec->Prepare();
CActiveScheduler::Start();
if(iError != KErrNone)
{
INFO_PRINTF2(_L("Prepare callback : error %d"), iError);
return EInconclusive;
}
if(iRec)
{
iError = KErrTimedOut;
rec->Record();
INFO_PRINTF1(_L("CVideoRecorderUtility: Record"));
// Wait for init callback
CActiveScheduler::Start();
if(iError == KErrNone)
{
ret = EPass;
}
User::After(1000000);
rec->Stop();
}
else
{
ret = EPass;
}
}
rec->Close();
INFO_PRINTF1(_L("CVideoRecorderUtility: Destroy"));
CleanupStack::PopAndDestroy(rec);
User::After(KOneSecond); // wait for deletion to shut down devsound
if(iError != KErrNone)
{
ERR_PRINTF2( _L("CVideoRecorderUtility failed with error %d"),iError );
}
CleanupStack::PopAndDestroy(2,&fs);
return ret;
}
TVerdict CTestMmfAclntOpenFile7905::DoTestStepL()
{
INFO_PRINTF1( _L("TestRecorder : Record File"));
TVerdict ret = EFail;
iError = KErrTimedOut;
RFs fs;
RFile file;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
User::LeaveIfError(fs.ShareProtected());
TPtrC filename;
if(!GetStringFromConfig(iSectName, iKeyName, filename))
{
return EInconclusive;
}
CMdaAudioRecorderUtility* recUtil = CMdaAudioRecorderUtility::NewL(*this);
CleanupStack::PushL(recUtil);
TUid invalidAudioController;
invalidAudioController.iUid = KInvalidAudioController;
User::LeaveIfError(file.Replace(fs,filename,EFileWrite));
CleanupClosePushL(file);
recUtil->OpenFileL(file, invalidAudioController, KNullUid, KNullUid, KFourCCNULL);
INFO_PRINTF1( _L("Initialise CMdaAudioRecorderUtility"));
CActiveScheduler::Start();
if( iError == KErrNotFound )
{
ret = EPass;
}
if(iError == KErrNone)
{
iError = KErrTimedOut;
recUtil->RecordL();
INFO_PRINTF1( _L("Record CMdaAudioRecorderUtility"));
CActiveScheduler::Start(); // open -> record
User::After(KFiveSeconds);
recUtil->Stop();
}
CleanupStack::PopAndDestroy(2, recUtil);
recUtil = NULL;
// Playback the file
if (iError == KErrNone)
{
if (filename.Right(4).Compare(_L(".wav"))==0)
{
// Wav file playback
CMdaAudioPlayerUtility* playUtil = CMdaAudioPlayerUtility::NewL(*this);
CleanupStack::PushL(playUtil);
TRAPD(err, playUtil->OpenFileL(filename));
if (err != KErrNone)
{
INFO_PRINTF2(_L("Error opening file for playback err = %d"), err);
ret = EFail;
}
CActiveScheduler::Start();
if (iError != KErrNone)
{
INFO_PRINTF2(_L("Error opening file for playback iError = %d"), iError);
ret = EFail;
}
playUtil->Play();
CActiveScheduler::Start();
CleanupStack::PopAndDestroy(playUtil);
if (iError != KErrNone)
{
INFO_PRINTF2(_L("Error during playback of recorded file iError=%d"), iError);
ret = EFail;
}
}
}
if( iError == KErrNone )
{
RFile file;
TInt size = 0;
User::LeaveIfError(file.Open(fs,filename,EFileRead));
CleanupClosePushL(file);
User::LeaveIfError(file.Size(size));
if(size > 0)
{
ret = EPass;
}
CleanupStack::PopAndDestroy(); //file
}
CleanupStack::PopAndDestroy(); // fs
ERR_PRINTF2( _L("CMdaAudioRecorderUtility completed with error %d"),iError );
User::After(KOneSecond);
return ret;
}
// -----------------------------------------------------------------------------
// CLibxml2Tester::TestSetInputBufferL
// test setting input buffer
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CLibxml2Tester::TestSetInputBufferInfosetL(CStifItemParser& aItem)
{
TPtrC pType;
aItem.GetNextString(pType);
TPtrC pDoc;
aItem.GetNextString(pDoc);
TPtrC pOut;
aItem.GetNextString(pOut);
iDoc = parser.ParseFileL(pDoc);
TBufC<100> chunkName(_L("ChunkContainer") );
TInt size = 2000;
TInt maxSize = 10000;
TInt offset = 0;
TInt binarySize = CID_1().Length();
// TBool isReadOnly = EFalse;
RChunk chunk;
chunk.CreateGlobal(chunkName, size, maxSize);
CleanupClosePushL(chunk);
TBuf8<32> contbuff = _L8("binary container some data...");
RFs aRFs;
aRFs.Connect();
CleanupClosePushL( aRFs );
RFile fp;
User::LeaveIfError( fp.Open(aRFs, _L("c:\\testing\\data\\xmleng\\efute\\input\\containers\\petit.jpg"), EFileRead) );
CleanupClosePushL(fp);
TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);
TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);
TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);
iDoc.DocumentElement().AppendChildL(bincont);
iDoc.DocumentElement().AppendChildL(chunkcont);
iDoc.DocumentElement().AppendChildL(filecont);
RArray<TXmlEngDataContainer> list;
CleanupClosePushL(list);
iDoc.GetDataContainerList(list);
HBufC8* buf = ReadFileL(pDoc);
CleanupStack::PushL(buf);
RFile fileHandle;
RFs aRFs_2;
aRFs_2.Connect();
CleanupClosePushL( aRFs_2 );
User::LeaveIfError( fileHandle.Replace( aRFs_2, pOut, EFileStream | EFileWrite | EFileShareExclusive));
CleanupClosePushL( fileHandle );
CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );
CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, RetDeserializerType(pType) );
CleanupStack::PushL( des );
des->SetInputBuffer(buf->Des());
des->UseExternalDataL( list );
des->DeserializeL();
CleanupStack::PopAndDestroy( 9 );
return KErrNone;
}
void CRuleManager::WriteToFile(RFile& file,CRule* aRule)
{
HBufC8* name = CCommonUtils::ConvertToUTF8FromUnicode(aRule->GetName());
file.Write(name->Des());
delete name;
file.Write(KRuleSymbolSplit);
TBuf8<16> uid;
uid.AppendNum((aRule->GetUid().iUid));
file.Write(uid);
file.Write(KRuleSymbolSplit);
TBuf8<2> type;
type.AppendNum(aRule->GetType());
file.Write(type);
file.Write(KRuleSymbolSplit);
if (aRule->GetType() == 0)
{
TBuf8<8> count;
count.AppendNum(aRule->GetCountDown());
file.Write(count);
}
else
{
TBuf8<8> count;
TimeFormat(aRule->GetClock(),count);
file.Write(count);
}
file.Write(KRuleSymbolSplit);
HBufC8* rulename = CCommonUtils::ConvertToUTF8FromUnicode(aRule->GetRuleName());
file.Write(rulename->Des());
delete rulename;
file.Write(KRuleSymbolSplit);
TBuf8<2> lunch;
lunch.AppendNum(aRule->IsLunchRun());
file.Write(lunch);
file.Write(KRuleSymbolEnd);
}
EXPORT_C TInt TEFparser::GetSectionData(TDesC& aScriptFilepath, TPtrC& aSectiontag, TDesC16 &aTocspTestFile, RFs& aFs)
{
TInt err = KErrNone;
TInt pos = 0;
RFile file;
// open the .ini file
if (BaflUtils::FolderExists(aFs, aScriptFilepath))
{
if (BaflUtils::FileExists( aFs, aScriptFilepath ))
{
file.Open(aFs, aScriptFilepath, EFileRead | EFileShareAny);
TFileText aLineReader;
TBuf<256> iLine;
TBuf<256> tempsectID;
// create the section name to search for
tempsectID.Copy(KOpenBrk);
tempsectID.Append(aSectiontag);
tempsectID.Append(KCloseBrk);
// read the ini file a line at a time until you find the the section name
aLineReader.Set(file);
TInt foundTag = -1;
while (err != KErrEof && foundTag != 0)
{
err = aLineReader.Read(iLine);
if (err != KErrEof)
foundTag = iLine.Find(tempsectID);
}
// create the next open bracket to search for
TBuf<2> tempopenBrk;
tempopenBrk.Copy(KOpenBrk);
RFile testfile;
err = KErrNone;
foundTag = -1;
// while not at the end of the file and not found the next open bracket
while (err != KErrEof && foundTag != 0)
{
// get the next line of the .ini file
err = aLineReader.Read(iLine);
if (err != KErrEof)
{
// if the line of the file doesn't contain an open bracket, we are still in the section body
foundTag = iLine.Find(tempopenBrk);
if (BaflUtils::FolderExists(aFs, aTocspTestFile) && foundTag != 0)
{
// open the test file we are going to write all our section info into
if (BaflUtils::FileExists( aFs, aTocspTestFile ))
{
testfile.Open(aFs, aTocspTestFile, EFileWrite|EFileShareAny);
testfile.Seek(ESeekEnd, pos);
}
else
{
User::LeaveIfError(testfile.Create(aFs, aTocspTestFile, EFileWrite|EFileShareAny));
testfile.Open(aFs, aTocspTestFile, EFileWrite|EFileShareAny);
}
// append to line of the file end of line characters
iLine.Append(_L("\r\n"));
// write line of the code out to the test file in UNICODE format
TPtrC8 tmpPoint((TText8*)iLine.Ptr(),iLine.Size());
testfile.Write(tmpPoint);
testfile.Flush();
}
testfile.Close();
}
}
}
}
return KErrNone;
}
LOCAL_C TInt WavRecord()
{
// Parse the commandline and get a filename to use
TLex l(CommandLine);
TParse destinationName;
if (destinationName.SetNoWild(l.NextToken(),0,0)!=KErrNone)
{
Test.Printf(_L("No arg, skipping\r\n"));
return(KErrArgument);
}
Test.Next(_L("Record Wav file"));
// Open the file for writing
TInt r;
RFile destination;
r = destination.Replace(Fs,destinationName.FullName(),EFileWrite);
if (r!=KErrNone)
{
Test.Printf(_L("Open file for write failed(%d)\n"), r);
return(r);
}
Test.Printf(_L("File opened for write\r\n"));
Test.Next(_L("Preparing to record"));
// Get the rate
TLex cl(l.NextToken());
TUint32 tmpRate;
TSoundRate rate;
r = cl.Val(tmpRate,EDecimal);
if (r == KErrNone && (r=SamplesPerSecondToRate(tmpRate,rate))==KErrNone)
{
Test.Printf(_L("Parsed rate: %d\r\n"), tmpRate);
RecordFormatBuf().iRate = rate;
}
else
{
Test.Printf(_L("Parse rate failed(%d)\r\n"),r);
RecordFormatBuf().iRate = ESoundRate32000Hz;
}
// Get number of channels
TLex cl_chan(l.NextToken());
TUint32 tmpChannels;
r = cl_chan.Val(tmpChannels,EDecimal);
if (r == KErrNone)
{
Test.Printf(_L("Parsed %d channels\r\n"),tmpChannels);
RecordFormatBuf().iChannels = tmpChannels;
}
else
{
Test.Printf(_L("Parse channels failed(%d)\r\n"), r);
RecordFormatBuf().iChannels = 2;
}
RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;
// Set the record buffer configuration.
RChunk chunk;
TTestSharedChunkBufConfig bufferConfig;
bufferConfig.iNumBuffers=4;
bufferConfig.iBufferSizeInBytes=RecordBufferSizeInBytes(RecordFormatBuf());
if (RecordCapsBuf().iRequestMinSize)
bufferConfig.iBufferSizeInBytes&=~(RecordCapsBuf().iRequestMinSize-1); // Keep the buffer length valid for the driver.
bufferConfig.iFlags=0;
PrintBufferConf(bufferConfig,Test);
TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);
r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);
if (r!=KErrNone)
{
Test.Printf(_L("Buffer configuration not supported(%d)\r\n"),r);
return(r);
}
// Set the audio record configuration.
RxSoundDevice.SetVolume(KSoundMaxVolume);
PrintConfig(RecordFormatBuf(),Test);
r=RxSoundDevice.SetAudioFormat(RecordFormatBuf);
if (r!=KErrNone)
{
Test.Printf(_L("Format not supported\r\n"));
return(r);
}
// Get length in seconds
TLex cl_seconds(l.NextToken());
TUint32 tmpSeconds;
r = cl_seconds.Val(tmpSeconds,EDecimal);
if (r == KErrNone)
{
Test.Printf(_L("Parsed %d seconds\r\n"),tmpSeconds);
}
else
{
Test.Printf(_L("Parse seconds failed(%d)\r\n"),r);
tmpSeconds=10;
}
TInt bytesToRecord = BytesPerSecond(RecordFormatBuf())*tmpSeconds;
Test.Next(_L("Recording..."));
// Lay down a file header
WAVEheader header;
TPtr8 headerDes((TUint8 *)&header, sizeof(struct WAVEheader), sizeof(struct WAVEheader));
// "RIFF"
header.ckID[0] = 'R'; header.ckID[1] = 'I';
header.ckID[2] = 'F'; header.ckID[3] = 'F';
// "WAVE"
header.wave_ckID[0] = 'W'; header.wave_ckID[1] = 'A';
header.wave_ckID[2] = 'V'; header.wave_ckID[3] = 'E';
// "fmt "
header.fmt_ckID[0] = 'f'; header.fmt_ckID[1] = 'm';
header.fmt_ckID[2] = 't'; header.fmt_ckID[3] = ' ';
// "data"
header.data_ckID[0] = 'd'; header.data_ckID[1] = 'a';
header.data_ckID[2] = 't'; header.data_ckID[3] = 'a';
header.nChannels = (TUint16)RecordFormatBuf().iChannels;
header.nSamplesPerSec = RateInSamplesPerSecond(RecordFormatBuf().iRate);
header.nBitsPerSample = 16;
header.nBlockAlign = TUint16((RecordFormatBuf().iChannels == 2) ? 4 : 2);
header.formatTag = 1; // type 1 is PCM
header.fmt_ckSize = 16;
header.nAvgBytesPerSec = BytesPerSecond(RecordFormatBuf());
header.data_ckSize = bytesToRecord;
header.ckSize = bytesToRecord + sizeof(struct WAVEheader) - 8;
Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\r\n"),
header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,
header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize, sizeof(struct WAVEheader));
r = destination.Write(headerDes);
TRequestStatus stat;
TInt length;
TPtrC8 buf;
TTime startTime;
startTime.HomeTime();
// Start off by issuing a record request.
TTime starttime;
starttime.HomeTime();
TInt bytesRecorded = 0;
RxSoundDevice.RecordData(stat,length);
TInt pausesToDo = 10;
pausesToDo = 0;
FOREVER
{
// Wait for the outstanding record request to complete.
User::After(6000);
User::WaitForAnyRequest();
if (stat==KRequestPending)
return(KErrGeneral);
TTime currentTime;
currentTime.HomeTime();
TInt64 elapsedTime = currentTime.Int64()-startTime.Int64(); // us
TTimeIntervalMicroSecondsBuf timeRecordedBuf;
if(RxSoundDevice.TimeRecorded(timeRecordedBuf) == KErrNone)
{
// Compare TimeRecorded with the actual elapsed time. They should be different, but not drift apart too badly...
TInt32 offset = TInt32(elapsedTime - timeRecordedBuf().Int64());
Test.Printf(_L("\telapsedTime - TimeRecorded = %d ms\n"), offset/1000);
}
// Check whether the record request was succesful.
TInt retOffset=stat.Int();
if (retOffset<0)
{
Test.Printf(_L("Record failed(%d)\r\n"),retOffset);
return(retOffset);
}
// Successfully recorded another buffer so write the recorded data to the record file and release the buffer.
buf.Set((const TUint8*)(chunk.Base()+retOffset),length);
r=destination.Write(buf);
if (r!=KErrNone)
{
Test.Printf(_L("File write failed(%d)\r\n"),r);
return(r);
}
r=RxSoundDevice.ReleaseBuffer(retOffset);
if (r!=KErrNone)
{
Test.Printf(_L("Release buffer failed(%d)\r\n"),r);
return(r);
}
Test.Printf(_L("Recorded %d more bytes - %d\r\n"),length,retOffset);
if((pausesToDo > 0) && (bytesRecorded > bytesToRecord/2))
{
--pausesToDo;
Test.Printf(_L("Pause\r\n"));
RxSoundDevice.Pause();
Test.Printf(_L("Paused, sleeping for 0.5 seconds\r\n"));
User::After(500*1000);
Test.Printf(_L("Resume\r\n"));
RxSoundDevice.Resume();
}
// Check whether we have now recorded all the data. If more to record then queue a further request
bytesRecorded+=length;
if (bytesRecorded<bytesToRecord)
{
Test.Printf(_L("RecordData\r\n"));
RxSoundDevice.RecordData(stat,length);
}
else
break;
}
RxSoundDevice.CancelRecordData(); // Stop the driver from recording.
TTime endtime;
endtime.HomeTime();
TInt64 elapsedTime = endtime.Int64()-starttime.Int64(); // us
Test.Printf(_L("Delta time = %d\r\n"),I64LOW(elapsedTime));
Test.Printf(_L("Seconds in buffer: %d (%d)\r\n"), bytesRecorded / header.nAvgBytesPerSec, (bytesRecorded / header.nAvgBytesPerSec)*1000000);
if (I64LOW(elapsedTime) <= (bytesRecorded / header.nAvgBytesPerSec)*1000000)
{
Test.Printf(_L("Time travelling; record took less time than it should have done\r\n"));
return(KErrGeneral);
}
chunk.Close();
destination.Close();
Test.Printf(_L("Record finished\r\n"));
return(KErrNone);
}
TVerdict CTSISHelperStepData::doTestStepL()
{
SetTestStepResult(EFail);
// Start the SISHelper
TPtrC sisFileName;
GetStringFromConfig(ConfigSection(),_L("SIS"), sisFileName);
Swi::TSisHelperStartParams params(sisFileName);
User::LeaveIfError(startSisHelper(params));
Swi::RSisHelper server;
User::LeaveIfError(server.Connect());
server.OpenDrmContentL(ContentAccess::EExecute);
TInt dataUnit = 0;
GetIntFromConfig(ConfigSection(),_L("DataUnit"), dataUnit);
TInt fileNumber = 0;
GetIntFromConfig(ConfigSection(),_L("FileNumber"), fileNumber);
// Create a file handle to pass
RFs sharedFs;
RFile sharedFile;
User::LeaveIfError(sharedFs.Connect());
User::LeaveIfError(sharedFs.ShareProtected());
_LIT(KTempFileName,"\\tsishelper.temp");
TDriveUnit sysDrive (RFs::GetSystemDrive());
TBuf<64> tempFileName (sysDrive.Name());
tempFileName.Append(KTempFileName);
User::LeaveIfError(sharedFile.Replace (sharedFs, tempFileName, EFileWrite));
TInt fakeUiHandler=0;
Swi::RUiHandler& uiHandler=reinterpret_cast<Swi::RUiHandler&>(fakeUiHandler);
User::LeaveIfError(server.ExtractFileL(sharedFs, sharedFile, fileNumber, dataUnit, uiHandler));
sharedFile.Close();
sharedFs.Close();
TPtrC expectedData;
GetStringFromConfig(ConfigSection(),_L("ExpectedData"), expectedData);
RFile oldFile;
User::LeaveIfError(oldFile.Open(iFs, expectedData, EFileRead));
RFile newFile;
User::LeaveIfError(newFile.Open(iFs, tempFileName, EFileRead)); // KErrBusy means SISHelper didn't close!
TInt expectedLength(0);
oldFile.Seek(ESeekEnd,expectedLength);
TInt actualLength(0);
newFile.Seek(ESeekEnd,actualLength);
if (expectedLength == actualLength)
{
TInt pos = 0;
oldFile.Seek(ESeekStart, pos);
newFile.Seek(ESeekStart, pos);
SetTestStepResult(EPass);
for (TInt i=0; i<expectedLength; i++)
{
TInt8 oldChar;
TInt8 newChar;
TPckg<TInt8> oldPkg(oldChar);
TPckg<TInt8> newPkg(newChar);
oldFile.Read(oldPkg);
newFile.Read(newPkg);
if (oldChar != newChar)
{
SetTestStepResult(EFail);
break;
}
}
}
oldFile.Close();
newFile.Close();
RFs fs;
User::LeaveIfError(fs.Connect());
// Delete the temp file
TInt error = fs.Delete(tempFileName);
if (error != KErrNone && error != KErrNotFound)
{
User::Leave(error);
}
fs.Close();
server.Close();
return TestStepResult();
}
void CTcpClientTestBase::SetLoggerL()
{
// Create a cinidata object for parsing the testexecute.ini
CTestExecuteIniData* parseTestExecuteIni = NULL;
TBuf<KMaxTestExecuteNameLength> resultFilePath;
TBuf<KMaxTestExecuteNameLength> xmlFilePath;
TInt logMode;
TInt logLevel;
TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL());
if (err == KErrNone)
{
CleanupStack::PushL(parseTestExecuteIni);
parseTestExecuteIni->ExtractValuesFromIni();
parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, resultFilePath);
parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlFilePath);
parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);
parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);
}
else
{
resultFilePath.Copy(KTestExecuteLogPath);
xmlFilePath.Copy(KTestExecuteLogPath);
logMode = TLoggerOptions(ELogHTMLOnly);
logLevel = RFileFlogger::TLogSeverity(ESevrAll);
}
Logger().SetLoggerOptions(logMode);
// Initialise a handle to the file logger
User::LeaveIfError(Logger().Connect());
RFs fS;
User::LeaveIfError(fS.Connect());
CleanupClosePushL(fS);
RFile file;
TBuf<KMaxTestExecuteNameLength> xmlLogFile(xmlFilePath);
TBuf<KMaxTestExecuteNameLength> logFile;
TBuf<KMaxTestExecuteNameLength> logFileNameFile(resultFilePath);
logFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile);
if(file.Open(fS,logFileNameFile,EFileRead | EFileShareAny) != KErrNone)
{
// For the old flogger we have to create an individual file
_LIT(KTxtLog,"TEIntSock.txt");
logFile.Copy(KTxtLog);
logMode = TLoggerOptions(0);
Logger().SetLoggerOptions(logMode);
}
else
{
CleanupClosePushL(file);
TBuf8<KMaxTestExecuteNameLength> logFile8;
TInt fileSize;
User::LeaveIfError(file.Size(fileSize));
User::LeaveIfError(file.Read(logFile8,fileSize));
logFile.Copy(logFile8);
xmlLogFile.Append(logFile);
_LIT(KXmlExtension,".xml");
xmlLogFile.Append(KXmlExtension);
_LIT(KHtmExtension,".htm");
logFile.Append(KHtmExtension);
CleanupStack::Pop(&file);
file.Close();
}
TBuf<KMaxTestExecuteLogFilePath> logFilePath(resultFilePath);
logFilePath.Append(logFile);
CleanupStack::Pop(&fS);
fS.Close();
if (logMode == 0 || logMode == 2)
{
User::LeaveIfError(Logger().HtmlLogger().CreateLog(logFilePath, RTestExecuteLogServ::ELogModeAppend));
}
if (logMode == 1 || logMode == 2)
{
User::LeaveIfError(Logger().XmlLogger().CreateLog(xmlLogFile,RFileFlogger::ELogModeAppend));
Logger().XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(logLevel));
}
if (parseTestExecuteIni != NULL)
{
CleanupStack::PopAndDestroy(parseTestExecuteIni);
}
}
LOCAL_C TInt WavPlay()
{
RChunk chunk;
// Parse the commandline and get a filename to use
TLex l(CommandLine);
TFileName thisfile=RProcess().FileName();
TPtrC token=l.NextToken();
if (token.MatchF(thisfile)==0)
token.Set(l.NextToken());
if (token.Length()==0)
{
// No args, skip to end
Test.Printf(_L("Invalid configuration\r\n"));
return(KErrArgument);
}
Test.Next(_L("Play Wav file"));
// Assume that the argument is a WAV filename
TFileName wavFilename=token;
TInt r;
RFile source;
r = source.Open(Fs,wavFilename,EFileRead);
if (r!=KErrNone)
{
Test.Printf(_L("Open failed(%d)\r\n"), r);
return(r);
}
// Read the pcm header
WAVEheader header;
TPtr8 headerDes((TUint8 *)&header,sizeof(struct WAVEheader),sizeof(struct WAVEheader));
r = source.Read(headerDes);
if (r!=KErrNone)
{
source.Close();
return(r);
}
Test.Printf(_L("Header Read %d bytes\r\n"),headerDes.Size());
if (headerDes.Size() != sizeof(struct WAVEheader)) // EOF
{
Test.Printf(_L("Couldn't read a header(%d bytes)\r\n"),headerDes.Size());
source.Close();
return(KErrCorrupt);
}
Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\n"),
header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,
header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize);
if (header.formatTag != 1) // not pcm
{
Test.Printf(_L("Format not PCM(%d)\r\n"),header.formatTag);
source.Close();
return(KErrNotSupported);
}
if (header.nBitsPerSample != 16) // not 16 bit
{
Test.Printf(_L("Format not 16 bit PCM(%d bits)\r\n"),header.nBitsPerSample);
source.Close();
return(KErrNotSupported);
}
TSoundRate rate;
if (SamplesPerSecondToRate(header.nSamplesPerSec,rate)!=KErrNone)
{
Test.Printf(_L("Format specifies a rate not supported(%d)\r\n"),header.nSamplesPerSec);
source.Close();
return(KErrNotSupported);
}
TxSoundDevice.AudioFormat(PlayFormatBuf); // Read back the current setting which must be valid.
PlayFormatBuf().iChannels = header.nChannels;
PlayFormatBuf().iRate = rate;
PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;
// Set the play buffer configuration.
TInt bufSize=BytesPerSecond(PlayFormatBuf())/8; // Large enough to hold 1/8th second of data.
bufSize&=~(header.nBlockAlign-1); // Keep the buffer length a multiple of the bytes per sample (assumes 16bitPCM, 1 or 2 chans).
if (PlayCapsBuf().iRequestMinSize)
bufSize&=~(PlayCapsBuf().iRequestMinSize-1); // Keep the buffer length valid for the driver.
TTestSharedChunkBufConfig bufferConfig;
bufferConfig.iNumBuffers=3;
bufferConfig.iBufferSizeInBytes=bufSize;
bufferConfig.iFlags=0;
PrintBufferConf(bufferConfig,Test);
TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);
r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);
if (r!=KErrNone)
{
Test.Printf(_L("Buffer configuration not supported(%d)\r\n"),r);
source.Close();
return(r);
}
TxSoundDevice.GetBufferConfig(bufferConfigBuf); // Read back the configuration - to get the buffer offsets
CHECK(bufferConfig.iBufferSizeInBytes==bufSize);
// Set the audio play configuration.
TxSoundDevice.SetVolume(KSoundMaxVolume - (KSoundMaxVolume / 4)); // set volume to 75%
PrintConfig(PlayFormatBuf(),Test);
r=TxSoundDevice.SetAudioFormat(PlayFormatBuf);
if (r!=KErrNone)
{
Test.Printf(_L("Format not supported\r\n"));
source.Close();
chunk.Close();
return(r);
}
TxSoundDevice.ResetBytesTransferred();
TInt32 bytesToPlay = header.data_ckSize;
TTime starttime;
starttime.HomeTime();
TRequestStatus stat[3];
TPtr8* tPtr[3];
TInt i;
for (i=0;i<3;i++)
tPtr[i]=new TPtr8(NULL,0);
TTime startTime;
startTime.HomeTime();
// Start off by issuing a play request for each buffer (assuming that the file is long enough). Use the full size
// of each buffer.
TInt stillToRead=bytesToPlay;
TInt stillNotPlayed=bytesToPlay;
TUint flags;
for (i=0 ; i<3 ; i++)
{
// Setup the descriptor for reading in the data from the file.
tPtr[i]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[i],0,bufSize);
// If there is still data to read to play then read this into the descriptor
// and then write it to the driver.
if (stillToRead)
{
r=source.Read(*tPtr[i],Min(stillToRead,bufSize));
if (r!=KErrNone)
{
Test.Printf(_L("Initial file read error(%d)\r\n"),r);
source.Close();
chunk.Close();
return(r);
}
stillToRead-=tPtr[i]->Length();
flags=(stillToRead>0)?0:KSndFlagLastSample;
TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],tPtr[i]->Length(),flags);
}
else
stat[i]=KRequestPending;
}
FOREVER
{
// Wait for any one of the outstanding play requests to complete.
User::WaitForAnyRequest();
TTime currentTime;
currentTime.HomeTime();
TInt64 elapsedTime = currentTime.Int64()-startTime.Int64(); // us
TTimeIntervalMicroSecondsBuf timePlayedBuf;
if(TxSoundDevice.TimePlayed(timePlayedBuf) == KErrNone)
{
// Compare TimePlayed with the actual elapsed time. They should be different, but not drift apart too badly...
TInt32 offset = TInt32(elapsedTime - timePlayedBuf().Int64());
Test.Printf(_L("\telapsedTime - TimePlayed = %d ms\n"), offset/1000);
}
// Work out which buffer this applies to
for (i=0 ; i<3 ; i++)
{
if (stat[i]!=KRequestPending)
break;
}
if (i>=3)
{
Test.Printf(_L("I/O error\r\n"));
source.Close();
chunk.Close();
return(KErrGeneral);
}
// Check that the transfer was succesful and whether we have now played all the file.
if (stat[i]!=KErrNone)
{
Test.Printf(_L("Play error(%d)\r\n"),stat[i].Int());
source.Close();
chunk.Close();
return(stat[i].Int());
}
Test.Printf(_L("Played %d bytes(%d) - %d\r\n"),tPtr[i]->Length(),i,stat[i].Int());
stillNotPlayed-=tPtr[i]->Length();
CHECK(stillNotPlayed>=0);
if (!stillNotPlayed)
break;
// Still more to be played so read the next part of the file into the descriptor for this
// buffer and then write it to the driver.
if (stillToRead)
{
TInt len=Min(stillToRead,bufSize);
// If we've got to the end of the file and the driver is particular about the request length then
// zero fill the entire buffer so we can play extra zeros after the last sample from the file.
if (len<bufSize && PlayCapsBuf().iRequestMinSize)
tPtr[i]->FillZ(bufSize);
// Read the next part of the file
r=source.Read(*tPtr[i],len); // This will alter the length of the descriptor
if (r!=KErrNone)
{
Test.Printf(_L("File read error(%d)\r\n"),r);
source.Close();
chunk.Close();
return(r);
}
stillToRead-=tPtr[i]->Length();
// If we've got to the end of the file and the driver is particular about the request length then
// round up the length to the next valid boundary. This is OK since we zero filled.
if (tPtr[i]->Length() < bufSize && PlayCapsBuf().iRequestMinSize)
{
TUint m=PlayCapsBuf().iRequestMinSize-1;
len=(tPtr[i]->Length() + m) & ~m;
}
// Write it to the driver.
flags=(stillToRead>0)?0:KSndFlagLastSample;
TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],len,flags);
}
else
stat[i]=KRequestPending;
}
// Delete all the variables again.
for (i=0 ; i<3 ; i++)
delete tPtr[i];
TTime endtime;
endtime.HomeTime();
Test.Printf(_L("Done playing\r\n"));
Test.Printf(_L("Bytes played = %d\r\n"),TxSoundDevice.BytesTransferred());
Test.Printf(_L("Delta time = %d\r\n"),endtime.Int64()-starttime.Int64());
chunk.Close();
source.Close();
return(KErrNone);
}
EXPORT_C void PrintContactL(const TDesC& aFilename, const CContactItem& aContact)
{
TBuf8<255> buf;
TBuf16<100> buf16;
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
fs.MkDirAll(aFilename);
RFile outFile;
User::LeaveIfError(outFile.Replace(fs, aFilename, EFileWrite | EFileStreamText));
CleanupClosePushL(outFile);
const CMyContact& myContact = reinterpret_cast<const CMyContact&>(aContact);
buf.Format(_L8("<table><tr><td>Attributes:</td><td>0x%08x</td></tr>\r\n"), myContact.iAttributes);
outFile.Write(buf);
buf.Format(_L8("<tr><td>Contact ID:</td><td>%d (%x)</td></tr>\r\n"), myContact.iId, myContact.iId);
outFile.Write(buf);
buf.Format(_L8("<tr><td>Template Ref ID:</td><td> %d (%x)</td></tr>\r\n"), myContact.iTemplateRefId, myContact.iTemplateRefId);
outFile.Write(buf);
/* outFile.Write(_L8("<tr><td>Last Modified:</td><td>"));
myContact.iLastModified.FormatL(buf16,KDateTimeFormat);
buf.Copy(buf16);
outFile.Write(buf);
outFile.Write(_L8("</td></tr>\r\n"));
outFile.Write(_L8("<tr><td>Creation Date:</td><td>"));
myContact.iCreationDate.FormatL(buf16,KDateTimeFormat);
buf.Copy(buf16);
outFile.Write(buf);
outFile.Write(_L8("</td></tr>\r\n"));*/
buf.Format(_L8("<tr><td>Access count:</td><td> %d</td></tr>\r\n"), myContact.iTemplateRefId, myContact.iAccessCount);
outFile.Write(buf);
if (aContact.Type() == KUidContactCard ||
aContact.Type() == KUidContactGroup ||
aContact.Type() == KUidContactOwnCard)
{
const CMyContactPlusGroup& myContactPlusGroup = reinterpret_cast<const CMyContactPlusGroup&>(aContact);
PrintIdArrayL(outFile, myContactPlusGroup.iGroups, _L8("Belongs to"), buf);
if (aContact.Type() == KUidContactGroup)
{
const CMyContactGroup& myContactGrp = reinterpret_cast<const CMyContactGroup&>(aContact);
PrintIdArrayL(outFile, myContactGrp.iItems, _L8("Contains"), buf);
}
}
outFile.Write(_L8("</table><br/>\r\n"));
PrintFieldsTableL(outFile, aContact.CardFields(), buf);
CleanupStack::PopAndDestroy(&outFile);
CleanupStack::PopAndDestroy(&fs);
}
void PrintFieldsTableL(RFile& outFile, const CContactItemFieldSet& fldSet, TBuf8<255>& buf)
{
SDescArr sTStorageType[] = {
_S("KStorageTypeText"),
_S("KStorageTypeStore"),
_S("KStorageTypeContactIt"),
_S("KStorageTypeDateTime")
};
SFlagsDict sFieldFlag[]= {
FF(EHidden),
FF(EReadOnly),
FF(ESynchronize),
FF(EDisabled),
FF(EUserMask),
FF(EOverRidesLabel),
FF(EUsesTemplateData),
FF(EUserAddedField),
FF(ETemplate),
FF(ELabelUnspecified),
FF(EDeleted),
FF(NbTestLast)
};
outFile.Write(_L8("<html><body><table width=100% cellpadding=1 cellspacing=1 border=1>"));
outFile.Write(_L8("<tr><td>Fld</td><td>Label</td><td>Field types:</td><td>Storg type</td>" \
"<td>Field</td><td>Attr</td><td>Ext.Att</td><td>Templ</td></tr>\r\n"));
const TInt numOfFields = fldSet.Count();
for (TInt i=0; i < numOfFields; ++i)
{
const CContactItemField& field = fldSet[i];
const CMyField& myField = reinterpret_cast<const CMyField&>(field);
const CContentType& conType = *myField.iContentType;
buf.Format(_L8("<tr><td>%d</td>"), myField.iId);
outFile.Write(buf);
outFile.Write(_L8("<td>"));
if (myField.iLabel)
{
buf.Copy(*myField.iLabel);
outFile.Write(buf);
}
outFile.Write(_L8("</td>\r\n"));
//test.Printf(_L("Field types are:"));
outFile.Write(_L8("<td>"));
for(TInt j=0; j < conType.FieldTypeCount(); ++j)
{
const TFieldType& fldType = conType.FieldType(j);
//test.Printf(_L(" %s"), VCardMaping(fldType));
const TPtrC str = VCardMaping(fldType);
buf.Copy(str);
outFile.Write(buf);
outFile.Write(_L8(",<br>"));
}
//Print Mapping of the field
outFile.Write(_L8("MP>: "));
const TPtrC mapp = VCardMaping(conType.Mapping());
buf.Copy(mapp);
outFile.Write(buf);
outFile.Write(_L8("</td>\r\n<td>"));
//test.Printf(_L("Storg type: %s"), sTStorageType[myField.iStorageType]);
const TPtrC str (sTStorageType[myField.iStorageType]);
buf.Copy(str);
outFile.Write(buf);
outFile.Write(_L8("</td>\r\n<td>"));
switch(myField.iStorageType)
{
case KStorageTypeText:
{
const TPtrC& textFld = static_cast<CContactTextField*>(field.Storage())->Text();
//test.Printf(_L("Text : %S"), textFld);
buf.Copy(textFld);
outFile.Write(buf);
}
break;
default:
break;
}
outFile.Write(_L8("</td>\r\n"));
//test.Printf(_L("Attributes: 0x%08x"), myField.iAttributes);
buf.Format(_L8("<td>0x%08x"), myField.iAttributes);
outFile.Write(buf);
for (TInt i = 0;; ++i)
{
const SFlagsDict& aFlag = sFieldFlag[i];
if (aFlag.iFlag & myField.iAttributes)
{
TPtrC str(aFlag.iDescript);
buf.Copy(str);
outFile.Write(_L8(",<br>"));
outFile.Write(buf);
}
if (aFlag.iFlag == NbTestLast)
{
break;
}
}
outFile.Write(_L8("</td>\r\n"));
//test.Printf(_L("Ext Attrib: 0x%08x"), myField.iExtendedAttributes);
buf.Format(_L8("<td>0x%08x</td>\r\n"), myField.iExtendedAttributes);
outFile.Write(buf);
//test.Printf(_L("Temp fldId: 0x%08x"), myField.iTemplateFieldId);
buf.Format(_L8("<td>%d</td>\r\n"), myField.iTemplateFieldId);
outFile.Write(buf);
outFile.Write(_L8("</tr>\r\n\r\n"));
}
outFile.Write(_L8("</table></body></html>\r\n"));
}
void Gource::mousetrace(Frustum& frustum, float dt) {
GLuint buffer[512];
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
glSelectBuffer(512, buffer);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
(void) glRenderMode(GL_SELECT);
glInitNames();
glPushName(0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPickMatrix((GLdouble) mousepos.x, (GLdouble) (viewport[3]-mousepos.y), 1.0f, 1.0f, viewport);
gluPerspective(90.0f, (GLfloat)display.width/(GLfloat)display.height, 0.1f, camera.getZFar());
camera.look();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
for(std::map<std::string,RUser*>::iterator it = users.begin(); it!=users.end(); it++) {
it->second->drawSimple(dt);
}
glDisable(GL_TEXTURE_2D);
glColor4f(1.0, 1.0, 1.0, 1.0);
root->drawSimple(frustum, dt);
glMatrixMode(GL_MODELVIEW);
mouse_hits = glRenderMode(GL_RENDER);
RFile* fileSelection = 0;
RUser* userSelection = 0;
if (mouse_hits > 0) {
int choice = buffer[3];
GLuint depth = buffer[1];
for (int loop = 1; loop < mouse_hits; loop++) {
if (buffer[loop*4+1] < depth) {
choice = buffer[loop*4+3];
depth = buffer[loop*4+1];
}
}
if(choice != 0) {
selectionDepth = depth;
std::map<int, RFile*>::iterator filetest;
std::map<int, RUser*>::iterator usertest;
if((filetest = tagfilemap.find(choice)) != tagfilemap.end()) {
fileSelection = filetest->second;
}
else if((usertest = tagusermap.find(choice)) != tagusermap.end()) {
userSelection = usertest->second;
}
}
}
glDisable(GL_DEPTH_TEST);
// is over a file
if(fileSelection != 0) {
// un hover a user
if(hoverUser != 0) {
hoverUser->setMouseOver(false);
hoverUser = 0;
}
if(fileSelection != hoverFile) {
//deselect previous selection
if(hoverFile !=0) hoverFile->setMouseOver(false);
//select new
fileSelection->setMouseOver(true);
hoverFile = fileSelection;
}
// is over a user
} else if(userSelection != 0) {
// un hover a file
if(hoverFile != 0) {
hoverFile->setMouseOver(false);
hoverFile = 0;
}
if(userSelection != hoverUser) {
//deselect previous selection
if(hoverUser !=0) hoverUser->setMouseOver(false);
//select new
userSelection->setMouseOver(true);
hoverUser = userSelection;
}
} else {
if(hoverFile!=0) hoverFile->setMouseOver(false);
if(hoverUser!=0) hoverUser->setMouseOver(false);
hoverFile=0;
hoverUser=0;
}
if(mouseclicked) {
if(hoverUser!=0) selectUser(hoverUser);
else if(hoverFile!=0) selectFile(hoverFile);
else selectUser(0);
}
}
// ---------------------------------------------------------
// CPosTp4::TestCompactL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp4::TestCompactL(TExecutionMode aExecutionMode)
{
_LIT(KFileSizeErr, "Returned file size is incorrect");
_LIT(KUsageErr, "Returned usage is incorrect");
_LIT(KFileSizeAfterCompactErr, "The file size after compact is not less than the file size before compact");
_LIT(KUsageAfterCompactErr, "The usage is equal or less than before compact");
RemoveDefaultDbL();
RemoveAllLmDatabasesL();
CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();
CleanupStack::PushL(manager);
// Create new test db
HPosLmDatabaseInfo* dbInfoDefault = HPosLmDatabaseInfo::NewLC(KTp4TestDb);
manager->CreateDatabaseL(*dbInfoDefault);
CleanupStack::PopAndDestroy(dbInfoDefault);
// This db must exist
manager->SetDefaultDatabaseUriL(KTp4TestDb);
CleanupStack::PopAndDestroy(manager);
CPosLandmarkDatabase* tmp = CPosLandmarkDatabase::OpenL(); // Make sure default database is created
CleanupStack::PushL(tmp);
if (tmp->IsInitializingNeeded())
{
ExecuteAndDeleteLD(tmp->InitializeL());
}
CleanupStack::PopAndDestroy(tmp);
RFile file;
User::LeaveIfError(file.Open(iFileSession, KLmTp4DefaultDbPath, EFileRead));
TInt fileSize=0;
file.Size(fileSize);
file.Close();
CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL();
CleanupStack::PushL(lmd);
CPosLandmarkDatabase::TSize size = lmd->SizeL();
AssertTrueSecL(size.iFileSize == fileSize, KFileSizeErr);
AssertTrueSecL(size.iUsage >= 0.0 && size.iUsage <= 1.0, KUsageErr); // For now, when compact is supported should usage be 100%
CPosLmOperation* op = lmd->CompactL();
switch (aExecutionMode)
{
case ESynchronous:
ExecuteAndDeleteLD(op);
break;
case EAsynchronous:
RunAsyncOperationLD(op); //*** async
break;
case EWaitForRequest:
CleanupStack::PushL(op);
RunAsyncOperationByWaitForReqL(op);
CleanupStack::PopAndDestroy(op);
break;
default:
break;
}
CPosLandmarkDatabase::TSize sizeAfterCompact = lmd->SizeL();
AssertTrueSecL(sizeAfterCompact.iFileSize < size.iFileSize, KFileSizeAfterCompactErr);
AssertTrueSecL(sizeAfterCompact.iUsage >= size.iUsage, KUsageAfterCompactErr);
CleanupStack::PopAndDestroy(lmd);
}
RFile CMtfTestActionAddFileAttachmentByHandle::OpenFileL(RFs& aFs, const TDesC& aFilePath)
{
RFile fileHandle;
User::LeaveIfError(fileHandle.Open(aFs, aFilePath, EFileRead));
return fileHandle;
}
TVerdict CTestStepConvertOpen::CompareFilesL(const TDesC& aCreatedFilename, const TDesC& aExpectedFilename, TInt aLength)
{
TVerdict verdict = EPass;
TInt position = 0;
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
TInt err = KErrNone;
RFile file;
User::LeaveIfError(file.Open(fs, aCreatedFilename, EFileRead|EFileShareAny));
CleanupClosePushL(file);
TInt fileSize=0;
err = file.Size(fileSize);
if (err != KErrNone) User::LeaveIfError(err);
RFileReadStream fileReadStream(file, position);
CleanupClosePushL(fileReadStream);
//read data from created file into descriptor
HBufC8* createdBuffer = HBufC8::NewL(aLength);
CleanupStack::PushL(createdBuffer);
TPtr8 createdBufferPtr = createdBuffer->Des();
TRAP(err, fileReadStream.ReadL(createdBufferPtr));
if ((err != KErrNone) && (err != KErrEof)) User::LeaveIfError(err); //EOF not an error ?
RFile file2;
User::LeaveIfError(file2.Open(fs, aExpectedFilename, EFileRead|EFileShareAny));
CleanupClosePushL(file2);
TInt file2Size;
err = file2.Size(file2Size);
if (err != KErrNone) User::LeaveIfError(err);
if(fileSize != file2Size)
{
INFO_PRINTF3(_L("Resulting file sizes do not match %d != %d"), fileSize, file2Size);
verdict = EFail;
}
else
{
//check contents
RFileReadStream fileReadStream2(file2, position);
CleanupClosePushL(fileReadStream2);
//read data from expected file into descriptor
HBufC8* expectedBuffer = HBufC8::NewL(aLength);
CleanupStack::PushL(expectedBuffer);
TPtr8 expectedBufferPtr = expectedBuffer->Des();
TRAP(err, fileReadStream2.ReadL(expectedBufferPtr));
if ((err != KErrNone) && (err != KErrEof)) User::LeaveIfError(err); //EOF not an error ?
//compare expected buffer with the newly create buffer
TInt result = expectedBuffer->Compare(*createdBuffer);
if (result != 0)
{
INFO_PRINTF1(_L("Resulting file contents do not match"));
verdict = EFail;
}
}
CleanupStack::PopAndDestroy(7); //file, fs, fileReadStream, createdBuffer, file2, fileReadStream2, expectedBuffer
return verdict;
}
PJ_END_DECL
/* Get Symbian phone model info, returning length of model info */
unsigned pj_symbianos_get_model_info(char *buf, unsigned buf_size)
{
pj_str_t model_name;
/* Get machine UID */
TInt hal_val;
HAL::Get(HAL::EMachineUid, hal_val);
pj_ansi_snprintf(buf, buf_size, "0x%08X", hal_val);
pj_strset2(&model_name, buf);
/* Get model name */
const pj_str_t st_copyright = {"(C)", 3};
const pj_str_t st_nokia = {"Nokia", 5};
char tmp_buf[64];
pj_str_t tmp_str;
_LIT(KModelFilename,"Z:\\resource\\versions\\model.txt");
RFile file;
RFs fs;
TInt err;
fs.Connect(1);
err = file.Open(fs, KModelFilename, EFileRead);
if (err == KErrNone) {
TFileText text;
text.Set(file);
TBuf16<64> ModelName16;
err = text.Read(ModelName16);
if (err == KErrNone) {
TPtr8 ptr8((TUint8*)tmp_buf, sizeof(tmp_buf));
ptr8.Copy(ModelName16);
pj_strset(&tmp_str, tmp_buf, ptr8.Length());
pj_strtrim(&tmp_str);
}
file.Close();
}
fs.Close();
if (err != KErrNone)
goto on_return;
/* The retrieved model name is usually in long format, e.g:
* "© Nokia N95 (01.01)", "(C) Nokia E52". As we need only
* the short version, let's clean it up.
*/
/* Remove preceding non-ASCII chars, e.g: "©" */
char *p = tmp_str.ptr;
while (!pj_isascii(*p)) { p++; }
pj_strset(&tmp_str, p, tmp_str.slen - (p - tmp_str.ptr));
/* Remove "(C)" */
p = pj_stristr(&tmp_str, &st_copyright);
if (p) {
p += st_copyright.slen;
pj_strset(&tmp_str, p, tmp_str.slen - (p - tmp_str.ptr));
}
/* Remove "Nokia" */
p = pj_stristr(&tmp_str, &st_nokia);
if (p) {
p += st_nokia.slen;
pj_strset(&tmp_str, p, tmp_str.slen - (p - tmp_str.ptr));
}
/* Remove language version, e.g: "(01.01)" */
p = pj_strchr(&tmp_str, '(');
if (p) {
tmp_str.slen = p - tmp_str.ptr;
}
pj_strtrim(&tmp_str);
if (tmp_str.slen == 0)
goto on_return;
if ((unsigned)tmp_str.slen > buf_size - model_name.slen - 3)
tmp_str.slen = buf_size - model_name.slen - 3;
pj_strcat2(&model_name, "(");
pj_strcat(&model_name, &tmp_str);
pj_strcat2(&model_name, ")");
/* Zero terminate */
buf[model_name.slen] = '\0';
on_return:
return model_name.slen;
}
// ---------------------------------------------------------
// CPosTp148::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp148::StartL()
{
BaflUtils::EnsurePathExistsL( iFileSession, KKMZFile );
// Delete the trace file
DeleteFileL(KFileTrace);
HBufC8* emptyBuffer=NULL;
iLog->Log(_L("Test with Tp148KMZFile.kmz"));
PrintParsedDataFromEncoderL(KKMZFile, *emptyBuffer, KErrNone, KKmzMimeType );
// Now compare tha trace file against the correct one
RFile correctFile;
RFile file;
iLog->Log(_L(">>>>>>>Comparing files<<<<<"));
TFileName filename;
CreateCorrectXmlFileL( KCorrectFile, filename );
User::LeaveIfError(correctFile.Open(iFileSession, filename, EFileRead));
CleanupClosePushL(correctFile);
User::LeaveIfError(file.Open(iFileSession, KFileTrace, EFileRead));
CleanupClosePushL(file);
HBufC* correctLinebuffer = HBufC::NewLC( KBufSize );
TPtr correctLine = correctLinebuffer->Des();
HBufC* linebuffer = HBufC::NewLC( KBufSize );
TPtr line = linebuffer->Des();
TInt err = KErrNone;
TBool done = EFalse;
TInt lineNr = 0;
while (ReadLn(correctFile, correctLine) != KErrEof && !done)
{
lineNr++;
err = ReadLn(file, line);
if ( err == KErrEof )
{
done = ETrue;
}
correctLine.Trim();
line.Trim();
if ( correctLine.Compare( line ) != KErrNone )
{
HBufC* buf = HBufC::NewLC( 128 );
TPtr buffer = buf->Des();
buffer.Format(_L("ERROR in TraceFile on line %d: "), lineNr);
iLog->Log( buffer );
iLog->Log( correctLine );
iLog->Log( line );
iErrorsFound++;
CleanupStack::PopAndDestroy( buf );
}
}
CleanupStack::PopAndDestroy( linebuffer );
CleanupStack::PopAndDestroy( correctLinebuffer );
CleanupStack::PopAndDestroy(&file);
CleanupStack::PopAndDestroy(&correctFile);
// EOF for trace file was reach before EOF in the correct file
if (done)
{
iLog->Log(_L("ERROR: EOF for Trace file was reached to early"));
iErrorsFound++;
}
DoCancelTestL();
if (iErrorsFound != KErrNone)
{
iLog->Log(_L("Errors found in TP148"));
User::Leave(-1);
}
}
void CTestUtilSessionSwi::ServiceL(const RMessage2& aMessage)
{
switch (aMessage.Function())
{
case ECopy:
{
HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1);
TInt err = Server().FileMan().Copy(*source, *destination, CFileMan::ERecurse | CFileMan::EOverWrite);
if (err == KErrNone)
{
// Turn off the read only attributes
TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors
err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse);
}
CleanupStack::PopAndDestroy(destination);
CleanupStack::PopAndDestroy(source);
aMessage.Complete(err);
break;
}
case EMove:
{
HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1);
TInt err = Server().FS().Rename(*source,*destination);
if (err == KErrNone)
{
// Turn off the read only attributes
TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors
err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse);
}
CleanupStack::PopAndDestroy(destination);
CleanupStack::PopAndDestroy(source);
aMessage.Complete(err);
break;
}
case EDelete:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TEntry entry;
TInt err = Server().FS().Entry(*fileName, entry);
if (err == KErrNone)
{
if (entry.IsDir())
{
TPath pathName(*fileName);
if (pathName[pathName.Length() - 1] != KPathDelimiter)
{
pathName.Append(KPathDelimiter);
}
err = Server().FileMan().RmDir(pathName);
}
else
{
err = Server().FS().Delete(*fileName);
}
}
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case ERmDir:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TParsePtrC parsePtr(*fileName);
if(parsePtr.IsRoot())
{
User::Leave(KErrAccessDenied);
}
TInt err = Server().FileMan().RmDir(*fileName);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EMkDirAll:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TInt err = Server().FS().MkDirAll(*fileName);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EFileExists:
{
delete iDetector;
iDetector=CTestFileDetector::NewL(aMessage,
Server().FS());
iDetector->DetectFile();
break;
}
case ELock:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
RFile lockFile;
TInt err = lockFile.Open(Server().FS(), *fileName, EFileWrite);
if (err == KErrNone)
iLockedFileHandles.Append(lockFile);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EUnlock:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TInt err = KErrNotFound;
TFileName lockedFileName;
for (TInt i = 0; i < iLockedFileHandles.Count() && err;i++)
{
TInt err2 = iLockedFileHandles[i].FullName(lockedFileName);
User::LeaveIfError(err2);
if (lockedFileName.MatchF(*fileName) != KErrNotFound)
{
iLockedFileHandles[i].Close();
iLockedFileHandles.Remove(i);
err = KErrNone;
}
}
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EFormat:
{
TInt drive = aMessage.Int0();
TBool formatFatOnly = aMessage.Int1();
TChar aDriveChar;
User::LeaveIfError(Server().FS().DriveToChar(drive, aDriveChar));
TBuf<3> bfDrv;
bfDrv.Append(aDriveChar);
bfDrv.Append(KBP);
RFormat format;
TInt count;
User::LeaveIfError(format.Open(Server().FS(), bfDrv, EHighDensity, count));
CleanupClosePushL(format);
if (formatFatOnly)
{
User::LeaveIfError(format.Next(count));
}
else
{
while (count > 0)
{
User::LeaveIfError(format.Next(count));
}
}
CleanupStack::PopAndDestroy(&format);
aMessage.Complete(KErrNone);
break;
}
case EMount:
{
TInt drive = aMessage.Int0();
User::LeaveIfError(Server().FS().Connect());
//Mount the drive synchronizely to make sure the drive is ready for the next operation
User::LeaveIfError(Server().FS().MountFileSystem(KFAT, drive, ETrue));
aMessage.Complete(KErrNone);
break;
}
case EUnMount:
{
TInt drive = aMessage.Int0();
TFileName fsName;
User::LeaveIfError(Server().FS().FileSystemName(fsName, drive));
User::LeaveIfError(Server().FS().DismountFileSystem(fsName, drive));
aMessage.Complete(KErrNone);
break;
}
case ESetReadOnly:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TInt setReadOnly = aMessage.Int1();
TUint setmask;
TUint clearmask;
if (setReadOnly)
{
// Setting read only attribute
setmask = KEntryAttReadOnly;
clearmask = 0;
}
else
{
// Clearing read only attribute
setmask = 0;
clearmask = KEntryAttReadOnly;
}
// Turn off the read only attributes
TTime time(0);
TInt err = Server().FileMan().Attribs(*fileName, setmask, clearmask, time);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EGetFileHandle:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
RFile file;
CleanupClosePushL(file);
User::LeaveIfError(file.Open(Server().FS(), *fileName, EFileRead | EFileShareReadersOnly));
User::LeaveIfError(file.TransferToClient(aMessage, 1));
CleanupStack::PopAndDestroy(2, fileName); // file
break;
}
case EWatchFile:
{
if (iFileWatcher)
{
if (iFileWatcher->IsActive())
{
aMessage.Complete(KErrServerBusy);
break;
}
else
{
delete iFileWatcher;
iFileWatcher = NULL;
}
}
// Create a new file watcher for this session
iFileWatcher = CFileWatcher::NewL(Server().FS(), aMessage);
break;
}
case EWatchFileCancel:
{
if (iFileWatcher)
{
iFileWatcher->Cancel();
aMessage.Complete(KErrNone);
}
else
{
// No file watch request to cancel!
aMessage.Complete(KErrNotReady);
}
break;
}
case EGetNumFiles:
{
HBufC* dirPath = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
CDir* dirContents = NULL;
User::LeaveIfError(Server().FS().GetDir(*dirPath, KEntryAttNormal, ESortNone, dirContents));
TPckg<TInt> numFiles(dirContents->Count());
delete dirContents;
aMessage.WriteL(1, numFiles);
aMessage.Complete(KErrNone);
CleanupStack::PopAndDestroy(dirPath);
break;
}
case ERegenerateCache:
{
#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
Swi::RSisRegistryWritableSession session;
User::LeaveIfError(session.Connect());
CleanupClosePushL(session);
session.RegenerateCacheL();
CleanupStack::PopAndDestroy(&session);
aMessage.Complete(KErrNone);
#else
aMessage.Complete(KErrNotSupported);
#endif
break;
}
case EGetFileHash:
{
HBufC* fileNameA = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
CMessageDigest* digest = CalculateFileHashLC(*fileNameA);
aMessage.WriteL(1, digest->Final());
aMessage.Complete(KErrNone);
CleanupStack::PopAndDestroy(2, fileNameA);
break;
}
default:
{
PanicClient(aMessage,EPanicIllegalFunction);
break;
}
}
}
// --------------------------------------------------------------------------
// CUPnPFileSharingEngine::StoreSharedContainerIDsL
// Creates main containers and starts sharing them
// --------------------------------------------------------------------------
//
TInt CUpnpSelectionWriter::StoreSharedContainerIDsL() const
{
__LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );
// Leave if aIdArray = NULL
if ( !iFileArray )
{
User::Leave(KErrArgument);
}
RFs fs;
RFile file;
User::LeaveIfError( fs.Connect() );
CleanupClosePushL(fs);
TFileName directory;
// Get private directory path
fs.SessionPath(directory);
// Try to create directory
TInt error = fs.MkDir(directory);
// it's ok if directory already exists
if (!(error != KErrNone && error != KErrAlreadyExists))
{
// Add file name
if ( iMediaType == EImageAndVideo )
{
directory.Append( KVisualFile );
}
else if ( iMediaType == EPlaylist )
{
directory.Append( KMusicFile );
}
error = file.Replace(fs, directory, EFileWrite );
if ( !error )
{
CleanupClosePushL( file );
RFileWriteStream writeStream(file);
CleanupClosePushL( writeStream );
for (TInt index = 0; index < iFileArray->Count(); index++)
{
// check that sharing of the container was succesful
if ( iOkItems.Find( index ) != KErrNotFound )
{
// Write identifiers to the file
writeStream << iFileArray->MdcaPoint(index);
}
}
// Clean up
CleanupStack::PopAndDestroy(&writeStream); // Close writeStream
CleanupStack::PopAndDestroy(&file); // Close file
}
}
CleanupStack::PopAndDestroy(&fs);
__LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
return error;
}
// ---------------------------------------------------------------------------------
// CUpnpTmServerDescriptionProvider::GetFile
//
// ---------------------------------------------------------------------------------
//
TInt CUpnpTmServerDescriptionProvider::GetFile( const TDesC8& /*aUri*/, RFile& aFile )
{
OstTraceFunctionEntry0( CUPNPTMSERVERDESCRIPTIONPROVIDER_GETFILE_ENTRY );
return ( aFile.Open( iFs, iFilePath, EFileShareReadersOnly | EFileRead ));
}
// -----------------------------------------------------------------------------
// CLibxml2Tester::DeserializeL
// deserialize from file, using setter SetInputFileL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CLibxml2Tester::DeserializeInfosetL( CStifItemParser& aItem)
{
TInt err;
TPtrC pDeserializerType;
aItem.GetNextString( pDeserializerType );
TPtrC pInputFile;
aItem.GetNextString( pInputFile );
TPtrC pOutputFile;
aItem.GetNextString( pOutputFile );
TPtrC pDirtyReturn;
aItem.GetNextString( pDirtyReturn );
TLex inputNum (pDirtyReturn);
TInt dirtyReturn;
inputNum.Val(dirtyReturn);
iDoc = parser.ParseFileL(pInputFile);
TBufC<100> chunkName(_L("ChunkContainer") );
TInt size = 2000;
TInt maxSize = 10000;
TInt offset = 0;
TInt binarySize = CID_1().Length();
// TBool isReadOnly = EFalse;
RChunk chunk;
chunk.CreateGlobal(chunkName, size, maxSize);
CleanupClosePushL(chunk);
TBuf8<32> contbuff = _L8("binary container some data...");
RFs aRFs;
aRFs.Connect();
CleanupClosePushL( aRFs );
RFile fp;
User::LeaveIfError( fp.Open(aRFs, _L("c:\\testing\\data\\xmleng\\efute\\input\\containers\\petit.jpg"), EFileRead) );
CleanupClosePushL(fp);
TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);
TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);
TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);
iDoc.DocumentElement().AppendChildL(bincont);
iDoc.DocumentElement().AppendChildL(chunkcont);
iDoc.DocumentElement().AppendChildL(filecont);
RArray<TXmlEngDataContainer> list;
CleanupClosePushL(list);
iDoc.GetDataContainerList(list);
RFile fileHandle;
RFs aRFs_2;
aRFs_2.Connect();
CleanupClosePushL( aRFs_2 );
User::LeaveIfError( fileHandle.Replace( aRFs_2, pOutputFile, EFileStream | EFileWrite | EFileShareExclusive));
CleanupClosePushL( fileHandle );
CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );
if( pDeserializerType.FindF( DEFAULT ) != KErrNotFound )
{
CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerDefault );
CleanupStack::PushL( des );
des->SetInputFileL( pInputFile );
TRAP(err,des->DeserializeL());
}
else if( pDeserializerType.FindF( XOP ) != KErrNotFound )
{
CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOP );
CleanupStack::PushL( des );
des->SetInputFileL( pInputFile );
TRAP(err,des->DeserializeL());
}
else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )
{
CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOPInfoset );
CleanupStack::PushL( des );
des->SetInputFileL( pInputFile );
des->UseExternalDataL( list );
TRAP(err,des->DeserializeL());
}
else if( pDeserializerType.FindF( GZIP ) != KErrNotFound )
{
CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerGZip );
CleanupStack::PushL( des );
des->SetInputFileL( pInputFile );
TRAP(err,des->DeserializeL());
}
CleanupStack::PopAndDestroy( 8 );
if ( err == dirtyReturn ) return KErrNone;
else return err;
}
/**
Reads the contents of the file passed in and checks
whether it contains any of the specified virus
signatures
@return A value depending on whether a known virus is
found within the file.
@param aFile A CFileCB object which can be used to read the file.
@internalComponent
*/
TInt CTestVirusHook::ScanFile(const TDesC& aName)
{
TInt r = KErrNone;
TInt pos = 0;
TInt size = 0;
// Rename the file
TPtrC tmpFile = _L("VS_RENAMED.VSH");
TParse parse;
parse.Set(aName, NULL, NULL);
parse.Set(parse.DriveAndPath(), &tmpFile, NULL);
r = iFs.Rename(aName, parse.FullName());
if(r != KErrNone)
return r;
RFile file;
r = file.Open(iFs, parse.FullName(), EFileRead);
if(r == KErrNone)
{
r = file.Size(size);
}
//If the file size is 0, then the file
//has just been created - so it can't contain
//a virus.
if(r != KErrNone || size == 0)
{
file.Close();
// Rename the file back
TInt err = iFs.Rename(parse.FullName(), aName);
if(err != KErrNone)
return err;
return r;
}
do
{
r = file.Read(pos, iScanBuf);
if (r != KErrNone)
{
break;
}
r = ScanBuffer();
pos += iScanBuf.Length();
} while ((r == KErrNotFound) && (iScanBuf.Length() == iScanBuf.MaxLength()));
file.Close();
// Rename the file back
TInt err = iFs.Rename(parse.FullName(), aName);
if(err != KErrNone)
return err;
if (r > 0)
{
//We've found an infection
return KErrAccessDenied;
}
else
{
return KErrNone;
}
}
// -----------------------------------------------------------------------------
// CLibxml2Tester::TestDisableFeatureL
// test setter disable feature
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CLibxml2Tester::TestDisableFeatureInfosetL(CStifItemParser& aItem)
{
TPtrC pType;
aItem.GetNextString(pType);
TPtrC pDoc;
aItem.GetNextString(pDoc);
TPtrC pOut1;
aItem.GetNextString(pOut1);
TPtrC pOut2;
aItem.GetNextString(pOut2);
iDoc = parser.ParseFileL(pDoc);
TBufC<100> chunkName(_L("ChunkContainer") );
TInt size = 2000;
TInt maxSize = 10000;
TInt offset = 0;
TInt binarySize = CID_1().Length();
// TBool isReadOnly = EFalse;
RChunk chunk;
chunk.CreateGlobal(chunkName, size, maxSize);
CleanupClosePushL(chunk);
TBuf8<32> contbuff = _L8("binary container some data...");
RFs aRFs;
aRFs.Connect();
CleanupClosePushL( aRFs );
RFile fp;
User::LeaveIfError( fp.Open(aRFs, _L("c:\\testing\\data\\xmleng\\efute\\input\\containers\\petit.jpg"), EFileRead) );
CleanupClosePushL(fp);
TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);
TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);
TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);
iDoc.DocumentElement().AppendChildL(bincont);
iDoc.DocumentElement().AppendChildL(chunkcont);
iDoc.DocumentElement().AppendChildL(filecont);
RArray<TXmlEngDataContainer> list;
CleanupClosePushL(list);
iDoc.GetDataContainerList(list);
RFile fileHandle_1;
RFile fileHandle_2;
// create session 1
RFs fs_1;
fs_1.Connect();
CleanupClosePushL( fs_1 );
// create session 2
RFs fs_2;
fs_2.Connect();
CleanupClosePushL( fs_2 );
User::LeaveIfError( fileHandle_1.Replace( fs_1, pOut1, EFileStream | EFileWrite | EFileShareExclusive ) );
CleanupClosePushL( fileHandle_1 );
CTestHandler* testHandle_1 = CTestHandler::NewLC( fileHandle_1 );
User::LeaveIfError( fileHandle_2.Replace( fs_2, pOut2, EFileStream | EFileWrite | EFileShareExclusive ) );
CleanupClosePushL( fileHandle_2 );
CTestHandler* testHandle_2 = CTestHandler::NewLC( fileHandle_2 );
CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle_1, RetDeserializerType(pType) );
CleanupStack::PushL( des );
des->UseExternalDataL( list );
des->EnableFeature( EReportNamespaceMapping );
des->DisableFeature( EReportNamespaceMapping );
if ( des->IsFeatureEnabled( EReportNamespaceMapping ) ) User::Leave(KErrGeneral);
des->DeserializeL( pDoc );
des->EnableFeature( EReportNamespaceMapping );
des->SetContentHandlerL( *testHandle_2 );
des->DisableFeature(EReportNamespaceMapping );
des->DeserializeL( fs_2, pDoc );
if(des->IsFeatureEnabled(EReportNamespaceMapping)) User::Leave(KErrGeneral);
CleanupStack::PopAndDestroy( 11 );
return KErrNone;
}
/**
Read the virus definition file C:\virusdef.txt and parse
its contents. Any virus definitions found in that file
are added to the KnownSignatures array so they can be
used by the virus scanning hook.
@internalComponent
@return KErrNone if the file was read and parsed
successfuly.
*/
TInt CTestVirusHook::ReadVirusDefinitionFile()
{
TInt r = iFs.Connect();
if (r != KErrNone)
return r;
r = iFs.SetNotifyChange(EFalse); // Disable change notifications
if (r != KErrNone)
return r;
//Open the virus definition file
RFile vsDefFile;
r = vsDefFile.Open(iFs, _L("C:\\virusdef.txt"), EFileShareAny);
if (r != KErrNone)
return r;
TInt fileSize=0;
r = vsDefFile.Size(fileSize);
if (r != KErrNone)
{
vsDefFile.Close();
return r;
}
HBufC8* defBuf=NULL;
TRAP(r,defBuf = HBufC8::NewL(fileSize));
if (r != KErrNone)
{
vsDefFile.Close();
return r;
}
TPtr8 ptr(defBuf->Des());
r = vsDefFile.Read(ptr);
if (r != KErrNone)
{
delete defBuf;
vsDefFile.Close();
return r;
}
//Now parse the definition file, putting the definitions into the hook's
//array of known virus signatures.
TInt bytesParsed = 0;
TInt stringBeginPos = 0;
TInt stringEndPos = 0;
TInt stringLength = 0;
HBufC8* signatureBuf = NULL;
while (bytesParsed < fileSize)
{
ptr.Set(defBuf->Des());
ptr.Set(&ptr[bytesParsed], fileSize-bytesParsed, fileSize-bytesParsed);
stringBeginPos = ptr.MatchF(_L8(":*;*"));
if (stringBeginPos < 0)
{
break;
}
stringBeginPos += 1; //:
stringBeginPos += bytesParsed;
ptr.Set(defBuf->Des());
ptr.Set(&ptr[stringBeginPos], fileSize-stringBeginPos, fileSize-stringBeginPos);
stringEndPos = ptr.MatchF(_L8("*;*"));
if (stringEndPos < 0)
{
break;
}
stringEndPos += bytesParsed;
stringLength = stringEndPos - stringBeginPos + 1;
ptr.Set(defBuf->Des());
TRAP(r,signatureBuf = HBufC8::NewL(stringLength));
TPtrC8 actualSig(ptr.Mid(stringBeginPos, stringLength));
TPtr8 ptr2(signatureBuf->Des());
ptr2.Append(actualSig);
iKnownSignatures[iSignaturesLoaded] = signatureBuf;
iSignaturesLoaded++;
bytesParsed += 1; //:
bytesParsed += stringLength;
bytesParsed += 1; //;
}
//Cleanup
delete defBuf;
vsDefFile.Close();
return r;
}
// ---------------------------------------------------------
// CPosTp17::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp17::StartL()
{
#ifdef __WINS__
_LIT(KNotSupported, "Test case is not supported on WINS, exucute it on target!");
LogErrorAndLeave(KNotSupported);
#else
_LIT(KErrors, "One or several Dll's have an incorrect size");
SetupTestDataL();
RFs session;
User::LeaveIfError(session.Connect());
CleanupClosePushL(session);
RFile file;
TBuf<1> drive= _L("c");
TBuf<KMaxDllFileNameLength> name;
name.Copy(iDllNames[0]);
name.Replace(0,1,drive);
if (file.Open(session, name, EFileRead) != KErrNone)
{
iLog->Put(_L("(Flashed) Use Drive Z:"));
drive.Copy(_L("z"));
}
else iLog->Put(_L("(Nonflashed) Use Drive C:"));
file.Close();
TBool errors=EFalse;
for (TInt i=0; i<iDllNames.Count(); i++)
{
name.Copy(iDllNames[i]);
name.Replace(0,1,drive);
//User::LeaveIfError(file.Open(session, name, EFileRead));
TInt err = file.Open(session, name, EFileRead);
if (err != KErrNone)
{
TBuf<70> buffe;
buffe.Append(_L("Error when opening file "));
buffe.Append(name);
LogErrorAndLeave(buffe, err);
}
CleanupClosePushL(file);
TInt fileSize=0;
file.Size(fileSize);
if (fileSize > iFootprints[i])
{
errors = ETrue;
_LIT(KDllSizeErr, "ERROR: %S is to big (%d), Max allowed ROM footprint is %d");
TBuf<255> info;
HBufC* temp = name.Alloc();
info.Format(KDllSizeErr, temp, fileSize, iFootprints[i]);
delete temp;
iLog->Put(info);
}
else
{
// Always log .dll size
_LIT(KDllSizeDebug, "%S is (%d), Max allowed ROM footprint is %d");
TBuf<255> info;
HBufC* temp = name.Alloc();
info.Format(KDllSizeDebug, temp, fileSize, iFootprints[i]);
delete temp;
iLog->Put(info);
}
CleanupStack::PopAndDestroy(&file);
}
CleanupStack::PopAndDestroy(&session);
if (errors)
{
LogErrorAndLeave(KErrors);
}
#endif
}
/**
* Installs a component by file handle using opaque arguments/results
*/
static TInt sifByHandleAndArgsAndResultsInstallL()
{
// Open file handle to the installation file
RFs fs;
TInt err = fs.Connect();
if (KErrNone != err)
{
ELOG1(EJavaConverters,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot connect to RFs, err %d", err);
User::Leave(err);
}
CleanupClosePushL(fs);
// If the file server session is not shared, USIF server crashes with KERN-EXEC 44
err = fs.ShareProtected();
if (KErrNone != err)
{
ELOG1(EJavaConverters,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot share RFs, err %d", err);
User::Leave(err);
}
// TEMP TEST
RFile installFile;
err = installFile.Open(fs, KTestMIDlet3, EFileShareReadersOnly | EFileRead);
if (KErrNone != err)
{
ELOG1(EJavaConverters,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot open "
"E:\\stopwatch10midp2.jad, err %d", err);
User::Leave(err);
}
CleanupClosePushL(installFile);
LOG(EJavaConverters, EInfo,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: installFile handle opened");
RSoftwareInstall installer;
err = installer.Connect();
if (KErrNone != err)
{
ELOG1(EJavaConverters,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: Cannot connect to RSoftwareInstall, err %d", err);
User::Leave(err);
}
CleanupClosePushL(installer);
LOG(EJavaConverters, EInfo,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: RSoftwareInstall connected");
TRequestStatus status;
COpaqueNamedParams *arguments = COpaqueNamedParams::NewL();
CleanupStack::PushL(arguments);
COpaqueNamedParams *results = COpaqueNamedParams::NewL();
CleanupStack::PushL(results);
// Silent installation request
arguments->AddIntL(KSifInParam_InstallSilently, 1);
// drive E:
arguments->AddIntL(KSifInParam_Drive, 4);
// 0 is TSifPolicy::EUserAllowed == Yes
arguments->AddIntL(KSifInParam_PerformOCSP, 0);
arguments->AddIntL(KSifInParam_IgnoreOCSPWarnings, 0);
arguments->AddIntL(KSifInParam_AllowUpgrade, 0);
arguments->AddIntL(KSifInParam_AllowUntrusted, 0);
arguments->AddIntL(KSifInParam_AllowOverwrite, 0);
arguments->AddIntL(KSifInParam_AllowDownload, 0);
// TEMP TEST prevent overflow
// arguments->AddStringL(KSifInParam_UserName, KUserName);
// arguments->AddStringL(KSifInParam_Password, KPassWord);
arguments->AddStringL(KSifInParam_SourceUrl, KSourceUrl);
arguments->AddIntL(KSifInParam_IAP, 3);
arguments->AddStringL(KSifInParam_Charset, KEmptyString);
arguments->AddStringL(KSifInParam_MimeType, KJadMimeType);
LOG(EJavaConverters, EInfo,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: arguments created");
installer.Install(installFile, *arguments, *results, status);
User::WaitForRequest(status);
LOG1(EJavaConverters, EInfo,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: The return status of install operation was %d", status.Int());
TInt componentId = 0;
TBool idExisted = results->GetIntByNameL(KSifOutParam_ComponentId, componentId);
if ( idExisted )
{
LOG1(EJavaConverters, EInfo,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: Component id was %d", componentId);
}
else
{
LOG(EJavaConverters, EInfo,
"testsifapi: sifByHandleAndArgsAndResultsInstallL: No component id was returned");
}
// free resources before returning
CleanupStack::PopAndDestroy(5);
return componentId;
}
/** Compares 2 vcf fie
@param aExpectedFile The expected vcf file
@param aFile This is the vcf file produced, and will be compared against aExpectedFile
@param aProperty This is the property we are interested in
*/
void CTestCompareCntFiles::CompareFileL(const TDesC& aExpectedFile, const TDesC& aFile, TDes8& aProperty)
{
RFile fileExpected;
RFile fileOutput;
CleanupClosePushL(fileExpected);
CleanupClosePushL(fileOutput);
TInt err = KErrNone;
err = fileExpected.Open(iFsSession, aExpectedFile, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF2(_L("Unable to open file: %S"), &aExpectedFile);
SetTestStepResult(EFail);
SetTestStepError(err);
}
err = fileOutput.Open(iFsSession, aFile, EFileRead);
if (err != KErrNone)
{
ERR_PRINTF2(_L("Unable to open file: %S"), &aFile);
SetTestStepResult(EFail);
SetTestStepError(err);
}
RFileReadStream streamExpected(fileExpected);
RFileReadStream streamOutput(fileOutput);
CleanupClosePushL(streamExpected);
CleanupClosePushL(streamOutput);
TBuf8<0x80> bufExpected,bufOutput;
TBool isProperty = EFalse;
TBool isPropertyExpected = EFalse;
TBool foundBothProperty = EFalse;
TBool flag = EFalse;
TInt err1 = KErrNone;
do // This do loop iterates through both files, until the end of file is found
{
do // This do loop iterates thorugh both files until both properties are found and compares them
{
foundBothProperty = EFalse;
if (!isProperty)
{
TRAP(err, streamExpected.ReadL(bufExpected, KLinefeedChar));
}
if (!isPropertyExpected)
{
TRAP(err1, streamOutput.ReadL(bufOutput, KLinefeedChar));
}
if (err != KErrEof || err1 != KErrEof)
{
isProperty = IsPropertyPresent(bufExpected, aProperty); // checks if aProperty
if(isProperty && err1 == KErrEof)
{
break;
}
isPropertyExpected = IsPropertyPresent(bufOutput, aProperty); // checks if aProperty
}
else
{
break;
}
if ((isProperty) && (isPropertyExpected))
{
foundBothProperty = ETrue;
flag = ETrue;
}
} while (!foundBothProperty); // exit 2nd do loop when both properties found
// Exists 2nd do loop, so both properties are found
if (err != KErrEof && err1 != KErrEof)
{
if(aProperty != KRevision)
{
CompareLinesL(bufExpected, bufOutput); // compares both properties
}
else
{
break;
}
}
// After comparing, gets the next property parameters in vcs file, if we have not reached end of file
TRAP(err, streamExpected.ReadL(bufExpected, KLinefeedChar));
TRAP(err1, streamOutput.ReadL(bufOutput, KLinefeedChar));
} while (err != KErrEof || err1 != KErrEof); // exits 2nd do loop when its reached the end of either file
TBuf<KMaxLengthField> buf;
buf.Copy(aProperty);
TPtrC ptr(buf);
if(flag)
{
INFO_PRINTF2(_L("Property: %S Exported properly"), &ptr);
}
else
{
INFO_PRINTF2(_L("Property: %S not exported"), &ptr);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(4, &fileExpected);
}
void CDstIntUtils::GenerateVCalL(RFs& aFs, const TDesC& aFileName, const TDesC& aStartTime, const TDesC& aEndTime)
{
RFile file;
file.Replace(aFs, aFileName, EFileWrite);
TBuf8<64> buf;
file.Write(_L8("BEGIN:VCALENDAR\r\n"));
file.Write(_L8("VERSION:1.0\r\n"));
file.Write(_L8("BEGIN:VEVENT\r\n"));
file.Write(_L8("CATEGORIES:MEETING\r\n"));
file.Write(_L8("DTSTART:"));
buf.Copy(aStartTime);
file.Write(buf);
file.Write(_L8("\r\n"));
file.Write(_L8("DTEND:"));
buf.Copy(aEndTime);
file.Write(buf);
file.Write(_L8("\r\n"));
file.Write(_L8("SUMMARY:TestMeeting\r\n"));
file.Write(_L8("DESCRIPTION:Test\r\n"));
file.Write(_L8("END:VEVENT\r\n"));
file.Write(_L8("END:VCALENDAR\r\n"));
file.Flush();
file.Close();
}