diff -r 000000000000 -r 08ec8eefde2f loggingservices/filelogger/TSRC/T_LOG.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/loggingservices/filelogger/TSRC/T_LOG.CPP Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,498 @@ +// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + + +#include +#include +#include + +GLDEF_D RTest test(_L("FLOGGER Test Code")); +GLDEF_D RFs fs; + +_LIT(KTestLogFileName1,"Log1.txt"); +_LIT(KTestLogFileName2,"Log2.txt"); +_LIT(KTestLogDir1,"Test1"); +_LIT(KTestLogDir2,"Test2"); +_LIT(KTestLogDir3,"Test3"); +_LIT(KTestLogDir4,"Test4"); +_LIT(KTestLogDir5,"Test5"); +_LIT(KTestLogFullDir1,"c:\\Logs\\Test1\\"); +_LIT(KTestLogFullDir2,"c:\\Logs\\Test2\\"); +_LIT(KTestLogFullDir3,"c:\\Logs\\Test3\\"); +_LIT(KTestLogFullDir4,"c:\\Logs\\Test4\\"); +_LIT(KTestLogFullDir5,"c:\\Logs\\Test5\\"); +_LIT(KTestLogFile1,"c:\\Logs\\Test1\\Log1.txt"); +_LIT(KTestLogFile2,"c:\\Logs\\Test1\\Log2.txt"); +_LIT(KTestLogFile3,"c:\\Logs\\Test2\\Log1.txt"); +_LIT(KTestLogFile4,"c:\\Logs\\Test3\\Log1.txt"); + +// 2.2.5 Wait for shutdown after closure of session +LOCAL_C void TestWaitForShutDown() + { + + + test.Printf(_L("\nWaiting for FLogger server shutdown")); + TInt i; + for (i=30; i>0; i--) + { + TFullName name=_L("*"); + _LIT(serverName,"FLogger server"); + name.Append(serverName); + TFindThread find(name); + if(find.Next(name)==KErrNone) + test.Printf(_L(".")); + else + break; + User::After(1000000); + } + + test(i); + test.Printf(_L("\nFLogger Server Shutdown after %d secs\n"), 29-i); + } + +LOCAL_C TInt DeleteFolder(const TDesC& aFolder) + { + + TUint temp; + _LIT(KLogDir,"c:\\Logs\\"); + TInt ret=fs.Att(KLogDir,temp); + if (ret==KErrPathNotFound) + return KErrNone; + else + { + TInt exists=fs.Att(aFolder,temp); + if (exists==KErrPathNotFound) + return KErrNone; + + if (exists!=KErrNotFound) + { + TFileName file1=aFolder; + file1.Append(KTestLogFileName1); + ret=fs.Delete(file1); + if (ret!=KErrNone && ret!=KErrNotFound) + return ret; + TFileName file2=aFolder; + file2.Append(KTestLogFileName1); + ret=fs.Delete(file2); + if (ret!=KErrNone && ret!=KErrNotFound) + return ret; + } + + CFileMan* fileman=NULL; + TRAP(ret,fileman=CFileMan::NewL(fs)); + TFileName folder; + folder.Copy(aFolder.Left(aFolder.Length()-1)); + ret=fileman->RmDir(folder); + delete fileman; + return ret; + } + } + +LOCAL_C void CreateFolderL(const TDesC& aFolder) + { + + TInt ret=fs.MkDirAll(aFolder); + if (ret!=KErrNone && ret!=KErrAlreadyExists) + User::Leave(ret); + } + +LOCAL_C void WriteToLog(RFileLogger& aLog) + { + + // 16 bit writes + TUint num1=100; + aLog.WriteFormat(_L("Writing a number to the log: %d"),num1); + test(aLog.LastError()==KErrNone); + TUint num2=200; + aLog.WriteFormat(_L("Writing two numbers to the log: %d, %d"),num1,num2); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(ETrue,ETrue); + aLog.Write(_L("Line should begin with date and time")); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(ETrue,EFalse); + aLog.Write(_L("Line should begin with date only")); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(EFalse,ETrue); + aLog.Write(_L("Line should begin with time only")); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(EFalse,EFalse); + aLog.Write(_L("Line should begin with nothing")); + test(aLog.LastError()==KErrNone); + aLog.Write(_L("")); + test(aLog.LastError()==KErrNone); + aLog.Write(_L("There should be a blank line above and below this one")); + test(aLog.LastError()==KErrNone); + aLog.Write(_L("")); + test(aLog.LastError()==KErrNone); + + // 8 bit writes + aLog.WriteFormat(_L8("Writing a number to the log: %d"),num1); + test(aLog.LastError()==KErrNone); + aLog.WriteFormat(_L8("Writing two numbers to the log: %d, %d"),num1,num2); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(ETrue,ETrue); + aLog.Write(_L8("Line should begin with date and time")); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(ETrue,EFalse); + aLog.Write(_L8("Line should begin with date only")); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(EFalse,ETrue); + aLog.Write(_L8("Line should begin with time only")); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(EFalse,EFalse); + aLog.Write(_L8("Line should begin with nothing")); + test(aLog.LastError()==KErrNone); + aLog.Write(_L8("")); + test(aLog.LastError()==KErrNone); + aLog.Write(_L8("There should be a blank line above and below this one")); + test(aLog.LastError()==KErrNone); + aLog.Write(_L8("")); + test(aLog.LastError()==KErrNone); + +// 2.2.1.5 Dump hexadecimal values + // Hex dump + const TText* hdr=_S("123456"); + const TText* mgn=_S(" "); + const TUint8* ptr=_S8("abcdefghijklmnopqrstuvwxyz"); + TInt len=26; + aLog.HexDump(hdr, mgn, ptr, len); + test(aLog.LastError()==KErrNone); + aLog.HexDump(NULL, mgn, ptr, len); + test(aLog.LastError()==KErrNone); + aLog.HexDump(hdr, NULL, ptr, len); + test(aLog.LastError()==KErrNone); + aLog.HexDump(hdr, mgn, NULL, len); + test(aLog.LastError()==KErrNone); + aLog.SetDateAndTime(ETrue,ETrue); + aLog.HexDump(hdr, mgn, ptr, len); + test(aLog.LastError()==KErrNone); + aLog.HexDump(NULL, mgn, ptr, len); + test(aLog.LastError()==KErrNone); + aLog.HexDump(hdr, NULL, ptr, len); + test(aLog.LastError()==KErrNone); + aLog.HexDump(hdr, mgn, NULL, len); + test(aLog.LastError()==KErrNone); + } + +// 2.2.1 Writing to two open log files at a time +// 2.2.1.3 Files are different +LOCAL_C void testTwoClientsL(TBool aValid) + { + + if (!aValid) + test(DeleteFolder(KTestLogFullDir1)==KErrNone); + else + CreateFolderL(KTestLogFullDir1); + + RFileLogger log1; + test(log1.Connect()==KErrNone); + RFileLogger log2; + test(log2.Connect()==KErrNone); + + log1.CreateLog(KTestLogDir1,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log1.LastError()==KErrNone); + test(log1.LogValid()==aValid); + + log2.CreateLog(KTestLogDir1,KTestLogFileName2,EFileLoggingModeOverwrite); + test(log2.LastError()==KErrNone); + test(log2.LogValid()==aValid); + + log1.Write(_L("This is written to log 1")); + test(log1.LastError()==KErrNone); + test(log1.LogValid()==aValid); + log2.Write(_L("This is written to log 2")); + test(log2.LastError()==KErrNone); + test(log2.LogValid()==aValid); + + WriteToLog(log1); + WriteToLog(log2); + + log1.CloseLog(); + log2.CloseLog(); + + TUint temp; + if (aValid) + { + test(fs.Att(KTestLogFile1,temp)==KErrNone); + test(fs.Att(KTestLogFile2,temp)==KErrNone); + } + else + { + test(fs.Att(KTestLogFile1,temp)==KErrPathNotFound); + test(fs.Att(KTestLogFile2,temp)==KErrPathNotFound); + } + + log1.Close(); + log2.Close(); + } + +// 2.2.2 Static appends +LOCAL_C void testStaticWrites(TBool aValid) + { + + if (!aValid) + test(DeleteFolder(KTestLogFullDir2)==KErrNone); + else + { + TRAPD(ret,(CreateFolderL(KTestLogFullDir2))); + test(ret==KErrNone); + } + + RFileLogger::Write(KTestLogDir2,KTestLogFileName1,EFileLoggingModeAppend,_L("Writing to the log")); + TUint num1=100; + RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L("Writing a number to the log: %d"),num1); + TUint num2=200; + RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L("Writing two numbers to the log: %d, %d"),num1,num2); + + RFileLogger::Write(KTestLogDir2,KTestLogFileName1,EFileLoggingModeAppend,_L8("Writing to the log")); + RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L8("Writing a number to the log: %d"),num1); + RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L8("Writing two numbers to the log: %d, %d"),num1,num2); + + const TText* hdr=_S("123456"); + const TText* mgn=_S(" "); + const TUint8* ptr=_S8("abcdefghijklmnopqrstuvwxyz"); + TInt len=26; + RFileLogger::HexDump(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend, hdr, mgn, ptr, len); + + TUint temp; + if (aValid) + test(fs.Att(KTestLogFile3,temp)==KErrNone); + else + test(fs.Att(KTestLogFile3,temp)==KErrPathNotFound); + } + +// 2.2.1 Writing to two open log files at a time +// 2.2.1.4 Files are the same +LOCAL_C void testTwoClientsOneFileL(TBool aValid) + { + + if (!aValid) + test(DeleteFolder(KTestLogFullDir3)==KErrNone); + else + CreateFolderL(KTestLogFullDir3); + + RFileLogger log1; + test(log1.Connect()==KErrNone); + RFileLogger log2; + test(log2.Connect()==KErrNone); + + log1.CreateLog(KTestLogDir3,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log1.LastError()==KErrNone); + test(log1.LogValid()==aValid); + + log2.CreateLog(KTestLogDir3,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log2.LastError()==KErrNone); + test(log2.LogValid()==aValid); + + log1.Write(_L("This is written from log session 1")); + test(log1.LastError()==KErrNone); + test(log1.LogValid()==aValid); + log2.Write(_L("This is written from log session 2")); + test(log2.LastError()==KErrNone); + test(log2.LogValid()==aValid); + + WriteToLog(log1); + WriteToLog(log2); + + log1.CloseLog(); + log2.CloseLog(); + + TUint temp; + if (aValid) + test(fs.Att(KTestLogFile4,temp)==KErrNone); + else + test(fs.Att(KTestLogFile4,temp)==KErrPathNotFound); + + log1.Close(); + log2.Close(); + } + +// 2.2.4 Invalid operations +// +// Check that buffers larger than KLogBufferSize can be written without error. +LOCAL_C void testInvalidOps1L() + { + + CreateFolderL(KTestLogFullDir4); + + RFileLogger log; + test(log.Connect()==KErrNone); + + log.CreateLog(KTestLogDir4,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log.LastError()==KErrNone); + test(log.LogValid()); + + TBuf<151> longBuf; + TChar ch('X'); + longBuf.Fill(ch,151); + test(longBuf.Length()==151); + log.Write(longBuf); // only those chars which will fit will be written + test(log.LastError()==KErrNone); + + TBuf8<151> longBuf8; + longBuf8.Fill(ch,151); + test(longBuf8.Length()==151); + log.Write(longBuf8); // only those chars which will fit will be written + test(log.LastError()==KErrNone); + + log.Close(); + } + +// Check that overlong directory names as well as file names cause an overflow error. +LOCAL_C void testInvalidOps2L() + { + + CreateFolderL(KTestLogFullDir4); + + RFileLogger log; + test(log.Connect()==KErrNone); + + TFileName dirName, fileName; + dirName.SetLength(dirName.MaxLength()); + log.CreateLog(dirName,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log.LastError()==KErrOverflow); + + fileName.SetLength(fileName.MaxLength()); + log.CreateLog(KTestLogDir1,fileName,EFileLoggingModeOverwrite); + test(log.LastError()==KErrOverflow); + + log.Close(); + } + +// 2.2.3 Access counting +LOCAL_C void TestAccessCountingL(TBool aValid) + { + + if (aValid) + CreateFolderL(KTestLogFullDir5); + else + DeleteFolder(KTestLogFullDir5); + + RFileLogger log; + test(log.Connect()==KErrNone); + + log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log.LastError()==KErrNone); + + log.CloseLog(); + + log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log.LastError()==KErrNone); + + log.CloseLog(); + + log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log.LastError()==KErrNone); + + log.Close(); + +// Test closing log twice + + test(log.Connect()==KErrNone); + + log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite); + test(log.LastError()==KErrNone); + + log.CloseLog(); + log.CloseLog(); // timer will be running if file exists + User::After(6000000); + log.CloseLog(); // timer will have expired + log.Close(); + +// Test closing session twice + + test(log.Connect()==KErrNone); + + log.Close(); + log.Close(); // timer will be running + TestWaitForShutDown(); + log.Close(); // timer will have expired + } + +LOCAL_C void doExampleL() + { + + User::LeaveIfError(fs.Connect()); + + // delete all files and folders + DeleteFolder(KTestLogFullDir1); // ignore return value + DeleteFolder(KTestLogFullDir2); // ignore return value + DeleteFolder(KTestLogFullDir3); // ignore return value + DeleteFolder(KTestLogFullDir4); + + test.Printf(_L("\nDo tests with Folders not existing....\n")); + + test.Start(_L("Two Sessions logging to different files: PDS-FILELOGGER-UT-4001")); + testTwoClientsL(EFalse); // folders do not exist + + test.Next(_L("Two sessions logging to one file: PDS-FILELOGGER-UT-4002")); + testTwoClientsOneFileL(EFalse); // folders do not exist + + test.Next(_L("Static logging: PDS-FILELOGGER-UT-4003")); + testStaticWrites(EFalse); // folders do not exist + + test.Next(_L("Test Closing and Access Counting: PDS-FILELOGGER-UT-4004")); + TestAccessCountingL(EFalse); + + test.Printf(_L("\nDo tests with Folders existing....\n")); + + test.Start(_L("Two Sessions logging to different files: PDS-FILELOGGER-UT-4001")); + testTwoClientsL(ETrue); // folders exist + + test.Next(_L("Two sessions logging to one file: PDS-FILELOGGER-UT-4002")); + testTwoClientsOneFileL(ETrue); // folders exist + + test.Next(_L("Static logging: PDS-FILELOGGER-UT-4003")); + testStaticWrites(ETrue); // folders exist + + test.Next(_L("Invalid Operations: PDS-FILELOGGER-UT-4005")); + testInvalidOps1L(); + test.Next(_L("Invalid Operations: PDS-FILELOGGER-UT-4006")); + testInvalidOps2L(); + + test.Next(_L("Test Closing and Access Counting: PDS-FILELOGGER-UT-4004")); + TestAccessCountingL(ETrue); + + RFileLogger log; + test(log.Connect()==KErrNone); + log.Close(); + + TestWaitForShutDown(); + test.End(); + + fs.Close(); + } + +GLDEF_C TInt E32Main() + { + + CTrapCleanup* cleanup=CTrapCleanup::New(); + + __UHEAP_MARK; + + test.Title(); + + TRAPD(ret,doExampleL()); + test(ret==KErrNone); + + test.End(); + test.Close(); + + __UHEAP_MARKEND; + + delete cleanup; + User::Heap().Check(); + return KErrNone; + }