TInt CFloggerTest028_Sync_Static_WriteUniBound::executeStepL()
{
TInt ret;
// clear the old log messages
RFileLogger flogger;
ret = flogger.Connect();
if ( ret == KErrNone )
{
flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
flogger.ClearLog();
flogger.Close();
RFileLogger::Write(KStdSubsysTag8, KStdCompTag8, KTestTooLongMessage16);
TRAPD(r, ret = DoTestCheckWriteL());
if (r != KErrNone)
ret = r;
}
return ret;
}
TInt CFloggerTest028_Sync_Static_Multiple2::executeStepL()
{
TInt ret;
// clear the old log messages
RFileLogger flogger;
ret = flogger.Connect();
if ( ret == KErrNone )
{
flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
flogger.ClearLog();
flogger.Close();
for (TInt loop = 1; loop <= KMultipleWriteStressTimes; loop++)
{
RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestMessage);
RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestTooLongMessage16);
DoTestWriteFormat(KTestMessageOneParam16,KTestMessageOneParamValue);
DoTestWriteFormat(KTestTooLongMessageOneParam16,KTestTooLongMessageOneParamValue);
RFileLogger::HexDump(KStdSubsysTag8, KStdCompTag8,KTestMessage8);
}
RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestEndMessage8);
TRAPD(r, ret = DoTestCheckWriteL());
if (r != KErrNone)
ret = r;
}
return ret;
}
TInt CFloggerTest028_Sync_Static_WriteFormatVUni::executeStepL()
{
TInt ret;
// clear the old log messages
RFileLogger flogger;
ret = flogger.Connect();
if ( ret == KErrNone )
{
flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
flogger.ClearLog();
flogger.Close();
DoTestWriteFormat(KTestMessageOneParam16,KTestMessageOneParamValue);
TRAPD(r, ret = DoTestCheckWriteL());
if (r != KErrNone)
ret = r;
}
return ret;
}
TInt CFloggerTest016_02::DoTestWriteFormat(TRefByValue<const TDesC8> aFmt,...)
{
RFileLogger theFlogger;
TInt ret = KErrGeneral;
ret = theFlogger.Connect(); //Just to clear the old log message
if ( ret == KErrNone)
ret = theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
if ( ret == KErrNone)
ret = theFlogger.ClearLog();
if ( ret == KErrNone)
theFlogger.Close();
User::After(100000);
if (ret == KErrNone)
{
VA_LIST list;
VA_START(list,aFmt);
RFileLogger::WriteFormat(KStdSubsysTag8, KStdCompTag8, aFmt, list);
User::After(100000);
return KErrNone;
}
return ret;
}
TInt CFloggerTest011_02::DoTestWrite()
{
TInt ret = KErrNone;
_LIT(KTestLongMessage,"TC 11_02: This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message"); //unicode test decriptor
RFileLogger theFlogger;
ret = theFlogger.Connect(); //Just to clear the old log message
if ( ret == KErrNone)
ret = theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
if ( ret == KErrNone)
ret = theFlogger.ClearLog();
if ( ret == KErrNone)
theFlogger.Close();
if (ret == KErrNone)
RFileLogger ::Write(KStdSubsysTag8, KStdCompTag8, KTestLongMessage);
User::After(100000);
return KErrNone;
}
TInt CFloggerTest017_03::DoTestWrite()
{
RFileLogger theFlogger;
TInt ret = KErrNone;
ret = theFlogger.Connect(); //Just to clear the old log message
if (ret == KErrNone)
ret = theFlogger.SetLogTags(KStdSubsysTag8,KStdCompTag8);
if (ret == KErrNone)
ret = theFlogger.ClearLog();
if (ret == KErrNone)
theFlogger.Close();
if (ret == KErrNone)
{
_LIT8(KDescText,"TC 17_3:Test Msg"); //8 bit test descriptor
//Write the test datas in the hexa format
RFileLogger::HexDump(KStdSubsysTag8,KStdCompTag8, KDescText);
return KErrNone;
}
return ret;
}
EXPORT_C void CSenLogger::Write(TInt aChannel, TInt aLevel, const TDesC8& aText)
{
RFileLogger* pLogger = Logger(aChannel, aLevel);
if (pLogger)
{
pLogger->Write(aText);
}
}
EXPORT_C void CSenLogger::WriteFormat(TInt aChannel, TInt aLevel, TRefByValue<const TDesC8> aFmt, VA_LIST& aList)
{
RFileLogger* pLogger = Logger(aChannel, aLevel);
if (pLogger)
{
pLogger->WriteFormat(aFmt, aList);
}
}
EXPORT_C void CSenLogger::WriteFormat(TInt aChannel, TInt aLevel, TRefByValue<const TDesC8> aFmt,...)
{
RFileLogger* pLogger = Logger(aChannel, aLevel);
if (pLogger)
{
VA_LIST list;
VA_START(list,aFmt);
pLogger->WriteFormat(aFmt, list);
}
}
TInt CFloggerTest016_01::DoTestWrite()
{
_LIT8(KTestMessageOne,"TC 16_01: The value of test integer variable :%d");
DoTestWriteFormat(KTestMessageOne, 100); //Write 8 bit formatted test descriptor
// connect so we can flush file buffer for heap check since timer is killed in heap checks
RFileLogger theFlogger;
theFlogger.Connect();
theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
ForceLogFlush(theFlogger);
theFlogger.Close();
return KErrNone;
}
void COptionNode::Dump(const TDesC& aTag, const TDesC& aFile)
{
RFileLogger f;
if (f.Connect() == KErrNone)
{
f.CreateLog(aTag, aFile, EFileLoggingModeAppend);
TInt i = 0;
while (KOptions[i].iCode != OpCode() && ++i < KNumberOfSupportedOptions){/*do nothing*/}
TInt n = iPtr8[1];
if (i < KNumberOfSupportedOptions)
{
f.WriteFormat(_L8("Option Code: %s, length: %d"), KOptions[i].iName, n);
}
else
{
f.WriteFormat(_L( "Option Code: %d, length %d" ), OpCode(), n );
}
if (GetItemLength() > 2)
{
f.HexDump(NULL, NULL, GetBodyPtr(), GetLength());
}
f.CloseLog();
f.Close();
}
}
TInt CFloggerTest012_01::DoTestWrite()
{
_LIT16(KTestMessageOne,"TEST 12.01: The value of test integer variable :%d"); //unicode test decriptor
RFileLogger::WriteFormat(KStdSubsysTag8, KStdCompTag8, KTestMessageOne, 100);
// connect so we can flush file buffer for heap check
RFileLogger theFlogger;
theFlogger.Connect();
theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
ForceLogFlush(theFlogger);
theFlogger.Close();
return KErrNone;
}
static void Log(const TDesC8& aText)
{
RFileLogger log;
TInt error = log.Connect();
if (error)
{
return;
}
_LIT(KLogFileDir, "pyexpat");
_LIT(KLogFileName, "pyexpat.txt");
log.CreateLog(KLogFileDir, KLogFileName,
EFileLoggingModeOverwrite);
log.Write(aText);
log.Close();
}
TInt CFloggerTest017_01::DoTestWrite()
{
_LIT8(KDescText, "TC 17_1:Test Msg----"); //Test body descriptor
//Write the test datas in the hexa format
RFileLogger::HexDump(KStdSubsysTag8,KStdCompTag8, KDescText, KHexTestHeader);
// connect so we can flush file buffer for heap check since timer is killed in heap checks
RFileLogger theFlogger;
theFlogger.Connect();
theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
ForceLogFlush(theFlogger);
theFlogger.Close();
return KErrNone;
}
TInt CFloggerTest002_01::executeStepL( )
{
INFO_PRINTF1(_L("Step 002.01 called "));
RFileLogger theFlogger;
TPtrC8 ptrSubSystem;
TPtrC8 ptrComponent;
ptrSubSystem.Set(_L8("SubSystem"));
ptrComponent.Set(_L8("Component"));
TInt result = theFlogger.Connect();
CleanupClosePushL(theFlogger);
theFlogger.SetLogTags(ptrSubSystem, ptrComponent);
CleanupStack::PopAndDestroy(); //logger
return result;
}
TInt CTestStepFlogger::DoTestConnect(RFileLogger& aLogger)
{
TInt ret = KErrNone;
TPtrC8 ptrSubSystem;
TPtrC8 ptrComponent;
ptrSubSystem.Set(_L8("SubSystem"));
ptrComponent.Set(_L8("Component"));
ret = aLogger.Connect();
if (ret == KErrNone)
ret = aLogger.SetLogTags(ptrSubSystem, ptrComponent); //SetLogTags() of Flogger called
if (ret == KErrNone)
ret = aLogger.ClearLog(); //clear the contents from the log
return ret;
}
EXPORT_C void CSenLogger::WriteAll(TInt aChannel, TInt aLevel, const TDesC8& aText)
{
RFileLogger* pLogger = Logger(aChannel, aLevel);
if ( pLogger )
{
TInt i = 0;
TInt lineAmount(KColumnWidth);
TInt length = aText.Length();
while(i<aText.Length())
{
if ( length - i < KColumnWidth )
{
lineAmount = length - i;
}
pLogger->Write(aText.Mid(i, lineAmount));
i += KColumnWidth;
}
}
}
TInt CFloggerTest025_BuildTestUrel4::executeStepL()
{
TInt ret;
RFileLogger theFlogger;
ret = theFlogger.Connect();
if ( ret == KErrNone)
{
theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
theFlogger.ClearLog();
theFlogger.Close();
TestLog4::Test();
ret = DoTestCheckWriteL();
}
return ret;
}
TInt CFloggerTest017_05::DoTestWrite()
{
RFileLogger theFlogger;
TInt ret = KErrNone;
ret = theFlogger.Connect(); //Just to clear the old log message
if (ret == KErrNone)
ret = theFlogger.SetLogTags(KStdSubsysTag8,KStdCompTag8);
if (ret == KErrNone)
ret = theFlogger.ClearLog();
if (ret == KErrNone)
theFlogger.Close();
if (ret == KErrNone)
{
//Write the test datas in the hexa format
RFileLogger::HexDump(KStdSubsysTag8,KStdCompTag8, KNullDesC8);
return KErrNone;
}
return ret;
}
GLDEF_C void Debug( TRefByValue<const TDesC> aText, ... )
{
#ifdef WINS
VA_LIST args;
VA_START( args, aText );
TBuf<KLogLineLength> buf;
buf.FormatList( aText, args );
RFileLogger logger;
TInt ret=logger.Connect();
if (ret==KErrNone)
{
logger.SetDateAndTime( EFalse,EFalse );
logger.CreateLog( KLogFolder, KLogFileName, EFileLoggingModeAppend );
TBuf<KLogTimeFormatLength> timeStamp;
TTime now;
now.HomeTime();
TDateTime dateTime;
dateTime = now.DateTime();
timeStamp.Format( KLogTimeFormat,
dateTime.Hour(), dateTime.Minute(),
dateTime.Second(), dateTime.MicroSecond() );
buf.Insert( 0, timeStamp );
logger.Write(buf);
}
logger.Close();
VA_END( args );
#else
RDebug::Print(aText);
#endif
}
void CEventLogger::SLog(TPtrC aString)
{
RFileLogger iLogger;
iLogger.Connect();
iLogger.CreateLog(KLogDir,KLogFile,EFileLoggingModeAppend);
iLogger.Write(aString);
iLogger.CloseLog();
iLogger.Close();
}
void CTestStepFlogger::ForceLogFlush(RFileLogger& aLogger)
{
const TInt KLineLen = KLogBufferSize - KMarginTemplateSize;
TBuf8<KLineLen> buf;
buf.SetLength(KLineLen);
for(TUint8 i = 0; i < KLineLen; i++)
{
buf[i] = i;
}
for(TInt j = 0; j < KHeapBufFillIterations; j++)
{
aLogger.Write(buf);
}
}
TInt CFloggerTest015_03::DoTestWrite()
{
TInt ret = KErrNone;
//8 bit test decriptor which is very long
_LIT8(KTestLongMessage,"TEST 15.03: This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message This is the long message"); //8 bit test decriptor
RFileLogger theFlogger;
ret = theFlogger.Connect(); //Just to clear the old log message
if ( ret == KErrNone)
ret = theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
if ( ret == KErrNone)
ret = theFlogger.ClearLog();
if ( ret == KErrNone)
theFlogger.Close();
if (ret == KErrNone)
RFileLogger ::WriteFormat(KStdSubsysTag8, KStdCompTag8, KTestLongMessage);
return KErrNone;
}
TInt CFloggerTest028_Sync_Setup::executeStepL()
{
TInt ret;
RFileLogger flogger;
flogger.Connect();
flogger.__DbgShutDownServer();
flogger.Close();
User::After(KWaitForFloggerShutdown);
TRAP(ret,constructFloggerIniL(KSyncTestsIniFileSettings));
flogger.Connect();
flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
flogger.Close();
return ret;
}
TInt CFloggerTest011_01::DoTestWrite()
{
TInt ret = KErrNone;
_LIT(KTestMessage,"TC 11_01: This is test messsage"); //unicode test decriptor
RFileLogger theFlogger;
//Just to clear the old log message
ret = theFlogger.Connect();
if ( ret == KErrNone)
{
ret = theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
if ( ret == KErrNone)
{
ret = theFlogger.ClearLog();
}
if ( ret == KErrNone)
{
theFlogger.Close();
}
}
if ( ret == KErrNone)
{
// Test case
RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestMessage);
// reconnect so we can flush file buffer for heap check
ret = theFlogger.Connect();
if (ret == KErrNone)
{
theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
ForceLogFlush(theFlogger);
theFlogger.Close();
}
}
return ret;
}
TInt CFloggerTest028_Sync_ConWriteUni::executeStepL()
{
TInt ret;
RFileLogger flogger;
ret = flogger.Connect();
if ( ret == KErrNone )
{
flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
flogger.ClearLog();
flogger.Write(KTestMessage);
flogger.Close();
TRAPD(r, ret = DoTestCheckWriteL());
if (r != KErrNone)
ret = r;
}
return ret;
}
TInt CFloggerTest028_Sync_ConWriteFormatEUniBound::executeStepL()
{
TInt ret;
RFileLogger flogger;
ret = flogger.Connect();
if ( ret == KErrNone )
{
flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
flogger.ClearLog();
flogger.WriteFormat(KTestTooLongMessageOneParam16,KTestTooLongMessageOneParamValue);
flogger.Close();
TRAPD(r, ret = DoTestCheckWriteL());
if (r != KErrNone)
ret = r;
}
return ret;
}
void CEventLogger :: SWrite(const TDesC& aModuleName, const TDesC& aMessage)
{
RFileLogger iLogger;
iLogger.Connect();
iLogger.CreateLog(KLogDir,KLogFile,EFileLoggingModeAppend);
_LIT(CrLfValue,"\r\n");
TBuf<5> CrLf;
CrLf.Format(_L("%S"),&CrLfValue);
_LIT(hyp,"-");
TBuf<2> Hyphen;
Hyphen.Format(_L("%S"),&hyp);
TInt MessageLen,ModuleNameLen,MessageToLogLen;
MessageLen = ModuleNameLen = MessageToLogLen = 0;
MessageLen = aMessage.Length();
ModuleNameLen = aModuleName.Length();
MessageToLogLen = ModuleNameLen;
MessageToLogLen += Hyphen.Length();
MessageToLogLen += MessageLen;
MessageToLogLen += CrLf.Length();
HBufC* MessageToLog = HBufC :: NewLC(MessageToLogLen);
MessageToLog->Des().Copy(aModuleName);
MessageToLog->Des().Append(Hyphen);
MessageToLog->Des().Append(aMessage);
MessageToLog->Des().Append(CrLf);
iLogger.Write(*MessageToLog);
CleanupStack::PopAndDestroy(MessageToLog);
iLogger.CloseLog();
iLogger.Close();
}
void CMsvPreferredDriveList::Print()
{
_LIT8(KLtBracket, "[");
_LIT8(KRtBracket, "]: DRIVE-NUM: ");
_LIT8(KDriveId, " DRIVE-ID: ");
_LIT8(KStatus, " STATUS: ");
_LIT8(KAvailable, "EMsvMessageStoreAvailableStatus");
_LIT8(KUnavailable, "EMsvMessageStoreUnavailableStatus");
_LIT8(KNotSupported, "EMsvMessageStoreNotSupportedStatus");
_LIT8(KDiskNotAvailable, "EMsvDriveDiskNotAvailableStatus");
_LIT8(KCorruptStore, "EMsvMessageStoreCorruptStatus");
_LIT8(KInvalid, "EMsvInvalidDriveStatus");
RFileLogger logger;
if (logger.Connect() == KErrNone)
{
logger.CreateLog(_L("msgs"), _L("DriveList.txt"), EFileLoggingModeAppend);
logger.SetDateAndTime(EFalse, EFalse);
logger.Write(_L(" Preferred Drive List:"));
logger.Write(_L("--------------------------------"));
logger.Write(_L(""));
}
TInt count = Count();
for(TInt index = 0; index < count; ++index)
{
RBuf8 text;
text.CreateL(100);
text.Append(KLtBracket);
text.AppendNum(index);
text.Append(KRtBracket);
text.AppendNum((*iDrives)[index].driveNum);
text.Append(KDriveId);
text.AppendNum((*iDrives)[index].driveId);
text.Append(KStatus);
switch((*iDrives)[index].status)
{
case EMsvMessageStoreAvailableStatus:
text.Append(KAvailable);
break;
case EMsvMessageStoreUnavailableStatus:
text.Append(KUnavailable);
break;
case EMsvMessageStoreNotSupportedStatus:
text.Append(KNotSupported);
break;
case EMsvDriveDiskNotAvailableStatus:
text.Append(KDiskNotAvailable);
break;
case EMsvMessageStoreCorruptStatus:
text.Append(KCorruptStore);
break;
case EMsvInvalidDriveStatus:
text.Append(KInvalid);
break;
}
logger.Write(text);
text.Close();
logger.Write(_L(""));
}
logger.CloseLog();
logger.Close();
}
//
//This heap failure member function is used to ensure correct operation in low-memory
// situations. It requires the flogger server to be started in order to inform the server
// on each loop iteration as to the new memory requirement. Thus, this harness is no
// good for cases where the flogger server must be shut down and restarted or
// when server is not meant to be running before the test case commences.
//
TInt CTestStepFlogger::doTestStepWithHeapFailureL( CTestStepFlogger& aTestStep, TInt lowMemory, TInt highMemory, TInt aReturnValue, TBool bypassChecks)
/**
@param bypassChecks allows a parameter to be passed to the executeStep to let it know that the
case is being used for heap checking. This is needed because most flogger methods do
not return an error code when they fail to write due to no memory. Thus, when running
the heap test the part of the test case which ensures the data was written to disk
may fail to find the data, and thus we need to bypass these checks.
@param aReturnValue - expected return value if everything works
@param lowMemory - amount of memory to start testing at - must be at least 10 lower than highMemory and test must fail due to low memory at this level
@param highMemory - amount of memory to stop testing at - if we reach this, test has failed.
*/
{
TInt ret=0;
TInt loop;
TPtrC8 ptrSubSystemTmp;
TPtrC8 ptrComponentTmp;
ptrSubSystemTmp.Set(_L8("SubSystem"));
ptrComponentTmp.Set(_L8("Component"));
RFileLogger logger;
User::LeaveIfError(logger.Connect());
CleanupClosePushL(logger);
logger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
// clear the log so that any previous test data is gone and not detected
logger.ClearLog();
User::After(KTimeToLog);
for (loop = lowMemory; loop < highMemory ; loop++)
{
INFO_PRINTF2(_L("%d"),loop);
logger.__DbgSetHeapFailure(loop);
ret = aTestStep.executeStep(bypassChecks);
if ( ret == KErrNoMemory)
{
//The heap failure has been trapped correctly
continue;
}
else if (( ret == aReturnValue ) && (loop != lowMemory))
{
//Test step normal behaviour
INFO_PRINTF4(_L("%S PASSED heap failure test, loop = %d return code==%d"),
&aTestStep.TestStepName(), loop, ret );
SetTestStepResult(EPass); break;
}
else
{
// test step has not returned the exepected error value ( which was either KErrNoMemory or aReturnValue )
INFO_PRINTF5(_L("%S *FAILED* heap failure test, loop=%d return code:%d expected:%d"),
&aTestStep.TestStepName(), loop, ret, aReturnValue );
SetTestStepResult(EFail); break;
}
}
// shutdown flogger server so we can see if any memory leaks - flogger svr will panic if there are
// This also means the next test does not get any residuals in the log buffers.
logger.ClearLog();
logger.__DbgShutDownServer();
CleanupStack::PopAndDestroy(); //logger
if (loop == highMemory)
{
// often the return code isn't checked, so make sure the test harness sees that it failed.
SetTestStepResult(EFail); return KErrGeneral;
}
if ( ret != aReturnValue )
{
// often the return code isn't checked, so make sure the test harness sees that it failed.
SetTestStepResult(EFail); return KErrGeneral;
}
return KErrNone;
}
