LOCAL_C TInt CreateVerifyFileX(const TDesC& aFileName, TInt aSize, RFs& aFs, TInt aPattern)
//
// Create and verify a file.
//
{
// Note, the directory structure is provided by MakeFileName(). Hence it
// is assumed at this point that the path to the file exists already.
RFile file;
TInt r;
r = file.Replace(aFs, aFileName, EFileWrite);
if (r!=KErrNone)
{
LogError( r, KReplace, aFileName, EFileWrite, 0 );
return(r);
}
// Grow it to the specified size by writing a pattern buffer to it
// Alternate the pattern buffer each time
RBuf8 wBuf;
r = wBuf.CreateMax(KCreateFileBufSize);
if(r != KErrNone)
{
LogError(r, KMemory, aFileName, 0, 0, __LINE__);
wBuf.Close();
file.Close();
return(r);
}
TInt i;
if (aPattern)
{
// ascending pattern
for (i = 0; i < KCreateFileBufSize; i++)
{
wBuf[i] = (TUint8) i;
}
}
else
{
// descending pattern
for (i = 0; i < KCreateFileBufSize; i++)
{
wBuf[i] = (TUint8) ((KCreateFileBufSize - 1) - i);
}
}
TInt pos;
TInt chunkSize;
TInt sectorCount = 0;
for (pos = 0; pos < aSize; pos += chunkSize)
{
wBuf[0]=(TUint8)i; // Insert sector count
chunkSize = Min((aSize-pos), KCreateFileBufSize);
r = file.Write(pos, wBuf, chunkSize);
if (r != KErrNone)
{
LogError(r, KWrite, aFileName, pos, chunkSize, __LINE__);
file.Close();
wBuf.Close();
return(r);
}
sectorCount++;
}
// Flush it
r=file.Flush();
if (r!=KErrNone)
{
LogError( r, KFlush, aFileName, 0, 0, __LINE__);
file.Close();
wBuf.Close();
return(r);
}
// Test still works if this is commented out just doesn't verify
// Read back and verify it
RBuf8 rBuf;
r = rBuf.CreateMax(KCreateFileBufSize);
if(r != KErrNone)
{
LogError( r, KMemory, aFileName, 0, 0, __LINE__);
file.Close();
wBuf.Close();
rBuf.Close();
return(KErrGeneral);
}
for (pos = 0;pos < aSize; pos += chunkSize)
{
chunkSize = Min((aSize-pos), KCreateFileBufSize);
r = file.Read(pos, rBuf, chunkSize);
if (r != KErrNone)
{
LogError(r, KRead, aFileName, pos, 0, __LINE__);
file.Close();
wBuf.Close();
rBuf.Close();
return(r);
}
wBuf[0] = (TUint8) i; // Insert sector count
wBuf.SetLength(chunkSize);
r = rBuf.Compare(wBuf);
if (r != 0)
{
LogError(r, KDataCompare, aFileName, 0, 0, __LINE__);
file.Close();
wBuf.Close();
rBuf.Close();
return(KErrGeneral);
}
}
//
file.Close();
wBuf.Close();
rBuf.Close();
return(KErrNone);
}
// ---------------------------------------------------------------------------------
// CUpnpTmFilteredAppList::TmInfoElementMatchingL
// Method is used to compare with each of the desired key-value of a particular
// info element.
// @param aTmInfoElement Reference to Terminal Mode Info Element object.
// @return Returns the boolean value ( ETrue/EFalse )
// ---------------------------------------------------------------------------------
//
TBool CUpnpTmFilteredAppList::TmInfoElementMatchingL( const CUpnpTmInfoElement& aTmInfoElement,
TInt aIndex )const
{
OstTraceFunctionEntry0( CUPNPTMFILTEREDAPPLIST_TMINFOELEMENTMATCHINGL_ENTRY );
TBool match(EFalse);
RBuf8 elementName;
CleanupClosePushL(elementName);
RBuf8 elementValue;
CleanupClosePushL(elementValue);
aTmInfoElement.GetTmInfoElementL(elementName,elementValue,aIndex );
// Check for required "protocolID" element
if ( elementName.Compare(KProtocolId()) == KErrNone )
{
const TDesC8& filterProtocol = iFilterInfo->ProtocolId();
if ( ( filterProtocol.Length() == KErrNone) ||
elementValue.MatchC(filterProtocol) != KErrNotFound )
{
// Either protocolID( required element )is unavailable or desired
// protocolID matches
match = ETrue;
}
}
// Check for optional "format" element
else if ( elementName.Compare(KFormat()) == KErrNone )
{
const TDesC8& filterFormat = iFilterInfo->Format();
if ( ( filterFormat.Length() == KErrNone) ||
elementValue.MatchC(filterFormat) != KErrNotFound )
{
// Either format ( optional element )is unavailable or desired "format" matches
match = ETrue;
}
}
// Check for optional "direction" element
else if ( elementName.Compare(KRemotingDirection()) == KErrNone )
{
const TDesC8& filterDirection = iFilterInfo->Direction();
if ( ( filterDirection.Length() == KErrNone) ||
elementValue.MatchC(filterDirection) != KErrNotFound )
{
// Either direction ( optional element )is unavailable or desired "direction" matches
match = ETrue;
}
}
// Check for optional "appCategory" element
else if ( elementName.Compare(KAppCategory()) == KErrNone )
{
const TDesC8& filterAppCategory = iFilterInfo->AppCategory();
if ( ( filterAppCategory.Length() == KErrNone) ||
elementValue.MatchC(filterAppCategory) != KErrNotFound )
{
// Either appCategory ( optional element )is unavailable or desired "appCategory" matches
match = ETrue;
}
}
// Check for optional "trustLevel" element for App Info Type
else if ( ( elementName.Compare(KTrustLevel()) == KErrNone ) &&
( aTmInfoElement.TerminalModeInfoType() == KAppInfo()) )
{
const TDesC8& filterAppTrustLevel = iFilterInfo->AppTrustLevel();
if ( ( filterAppTrustLevel.Length() == KErrNone) ||
elementValue.MatchC(filterAppTrustLevel) != KErrNotFound )
{
// Either trustLevel ( optional element )is unavailable or desired "trustLevel" matches
match = ETrue;
}
}
// Check for optional "contentCategory" element
else if ( elementName.Compare(KContCategory()) == KErrNone )
{
const TDesC8& filterContCategory = iFilterInfo->ContentCategory();
if ( ( filterContCategory.Length() == KErrNone) ||
elementValue.MatchC(filterContCategory) != KErrNotFound )
{
// Either contentCategory ( optional element )is unavailable or desired
// "contentCategory" matches
match = ETrue;
}
}
// Check for optional "contentRules" element
else if ( elementName.Compare(KContentRules()) == KErrNone )
{
const TDesC8& filterContentRules = iFilterInfo->ContentRules();
if ( ( filterContentRules.Length() == KErrNone) ||
elementValue.MatchC(filterContentRules) != KErrNotFound )
{
// Either contentRules ( optional element )is unavailable or desired "contentRules" matches
match = ETrue;
}
}
// Check for optional "trustLevel" element for Display Info type
else if ( ( elementName.Compare(KTrustLevel()) == KErrNone ) &&
( aTmInfoElement.TerminalModeInfoType() == KDisplayInfo()) )
{
const TDesC8& filterContTrustLevel = iFilterInfo->ContentTrustLevel();
if ( ( filterContTrustLevel.Length() == KErrNone) ||
elementValue.MatchC(filterContTrustLevel) != KErrNotFound )
{
// Either trustLevel ( optional element )is unavailable or desired "trustLevel" matches
match = ETrue;
}
}
// Check for optional "audioType" element
else if ( elementName.Compare(KAudioType()) == KErrNone )
{
const TDesC8& filterAudioType = iFilterInfo->AudioType();
if ( ( filterAudioType.Length() == KErrNone) ||
elementValue.MatchC(filterAudioType) != KErrNotFound )
{
// Either audioType ( optional element )is unavailable or desired "audioType" matches
match = ETrue;
}
}
CleanupStack::PopAndDestroy(2,&elementName);
OstTraceFunctionExit0( CUPNPTMFILTEREDAPPLIST_TMINFOELEMENTMATCHINGL_EXIT );
return match;
}
/** This sanity test method is executed at the start of the test run to verify that UPT methods in
this class are stable before any of the performance tests are carried out
// what tests does it do?
@return KErrNone if command was prepared correctly and system wide error code otherwise.
*/
TInt CUptCsvGenerator::TestL()
{
//define filepaths for the test csv files according to the test platform.
#ifdef __WINSCW__
_LIT(KTestFileAppend, "c:\\te_CSVoutputfileAppend.csv");
_LIT(KTestFileOverwrite, "c:\\te_CSVoutputfileOverwrite.csv");
#else
_LIT(KTestFileAppend, "e:\\te_CSVoutputfileAppend.csv");
_LIT(KTestFileOverwrite, "e:\\te_CSVoutputfileOverwrite.csv");
#endif
//initialise some generic data to write to csv
RArray<TInt64> atestdata1;
RArray<TInt64> atestdata2;
CleanupClosePushL(atestdata1);
CleanupClosePushL(atestdata2);
//data of the form:
//0 1 2 3 4 5 6 7 8 9
TInt data1element=10;
for(TInt i=0; i!=data1element;i++)
{
atestdata1.Append((TInt64) i);
}
//data of the form:
//0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000 11000
TInt data2element=12;
for(TInt i=0; i!=data2element;i++)
{
atestdata2.Append((TInt64) i*1000);
}
//now test the CSV Generator functions
//test the append data option - outputfile should contain an extra 6 lines of data of the form:
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
// 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
// 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
// 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000
TInt appendcount=3;
for(TInt i=0; i!=appendcount;i++)
{
OpenL(KTestFileAppend, ETrue);
WriteL(atestdata1);
WriteNewLineL();
WriteL(atestdata2);
WriteNewLineL();
Close();
}
//test the overwrite data option - outputfile should contain only 2 lines of data of the form:
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
// 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000
for(TInt i=0; i!=appendcount;i++)
{
OpenL(KTestFileOverwrite, EFalse);
WriteL(atestdata1);
WriteNewLineL();
WriteL(atestdata2);
WriteNewLineL();
Close();
}
// read the files back to check they are valid, as an automated check
RFs fsSession;
RFile appendfile;
RFile overwritefile;
TInt filesize;
User::LeaveIfError(fsSession.Connect());
//sizes in bytes of generated output csv data
TInt appendsize=appendcount*(sizeof(atestdata1)+sizeof(atestdata2)+2*sizeof(KCsvNewLine)+(data1element+data2element)*sizeof(KCsvComma));
TInt overwritesize=(sizeof(atestdata1)+sizeof(atestdata2)+2*sizeof(KCsvNewLine)+(data1element+data2element)*sizeof(KCsvComma));
// fill buffers used for data read from the outputted file
RBuf8 readappendfile;
readappendfile.CreateL(appendsize);
RBuf8 readoverwritefile;
readoverwritefile.CreateL(overwritesize);
CleanupClosePushL(readappendfile);
CleanupClosePushL(readoverwritefile);
// comparison data buffers used to contain the expected data
RBuf8 acompareappend;
acompareappend.CreateL(appendsize);
RBuf8 acompareoverwrite;
acompareoverwrite.CreateL(overwritesize);
CleanupClosePushL(acompareappend);
CleanupClosePushL(acompareoverwrite);
//fill comparison array for appended data
TInt err=FillReferenceBuffer(acompareappend, appendcount, atestdata1, data1element, atestdata2, data2element);
//first check the appended file by reading back the last 6 lines in the file and comparing with acompareappend
if(err==KErrNone)
{
if(appendfile.Open(fsSession, KTestFileAppend, EFileRead))
{
if(appendfile.Size(filesize))
{
if(appendfile.Read((filesize-sizeof(acompareappend)),readappendfile))
{
if(!readappendfile.Compare(acompareappend))
err=KErrGeneral;
}
}
}
}
// close test output csv file
appendfile.Close();
//given the above has passed,
//fill comparison array for overwritten data
if(err==KErrNone)
err=FillReferenceBuffer(acompareoverwrite, (TInt) 0, atestdata1, data1element, atestdata2, data2element);
//check the overwritten file by reading back the only 2 lines in the file and comparing with acompareoverwrite
//Note: as a thorough check- read from a zero offset
if(err==KErrNone)
{
if(overwritefile.Open(fsSession, KTestFileOverwrite, EFileRead))
{
if(overwritefile.Size(filesize))
{
if(overwritefile.Read(0,readoverwritefile))
{
if(!readoverwritefile.Compare(acompareoverwrite))
err=KErrGeneral;
}
}
}
}
// close test output csv file
overwritefile.Close();
CleanupStack::PopAndDestroy(&atestdata1);
CleanupStack::PopAndDestroy(&atestdata2);
CleanupStack::PopAndDestroy(&readappendfile);
CleanupStack::PopAndDestroy(&readoverwritefile);
CleanupStack::PopAndDestroy(&acompareappend);
CleanupStack::PopAndDestroy(&acompareoverwrite);
return err;
}
