1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 #include <e32test.h>

    18 #include <flogger.h>

    19 #include <f32file.h>

    20 

    21 GLDEF_D RTest test(_L("FLOGGER Test Code"));

    22 GLDEF_D RFs fs;

    23 

    24 _LIT(KTestLogFileName1,"Log1.txt");

    25 _LIT(KTestLogFileName2,"Log2.txt");

    26 _LIT(KTestLogDir1,"Test1");

    27 _LIT(KTestLogDir2,"Test2");

    28 _LIT(KTestLogDir3,"Test3");

    29 _LIT(KTestLogDir4,"Test4");

    30 _LIT(KTestLogDir5,"Test5");

    31 _LIT(KTestLogFullDir1,"c:\\Logs\\Test1\\");

    32 _LIT(KTestLogFullDir2,"c:\\Logs\\Test2\\");

    33 _LIT(KTestLogFullDir3,"c:\\Logs\\Test3\\");

    34 _LIT(KTestLogFullDir4,"c:\\Logs\\Test4\\");

    35 _LIT(KTestLogFullDir5,"c:\\Logs\\Test5\\");

    36 _LIT(KTestLogFile1,"c:\\Logs\\Test1\\Log1.txt");

    37 _LIT(KTestLogFile2,"c:\\Logs\\Test1\\Log2.txt");

    38 _LIT(KTestLogFile3,"c:\\Logs\\Test2\\Log1.txt");

    39 _LIT(KTestLogFile4,"c:\\Logs\\Test3\\Log1.txt");

    40 

    41 // 2.2.5 Wait for shutdown after closure of session 

    42 LOCAL_C void TestWaitForShutDown()

    43 	{

    44 

    45 	

    46 	test.Printf(_L("\nWaiting for FLogger server shutdown"));

    47 	TInt i;

    48 	for (i=30; i>0; i--)

    49 		{

    50 		TFullName name=_L("*");

    51 		_LIT(serverName,"FLogger server");

    52 		name.Append(serverName);

    53 		TFindThread find(name);

    54 		if(find.Next(name)==KErrNone)

    55 			test.Printf(_L("."));

    56 		else

    57 			break;

    58 		User::After(1000000);

    59 		}

    60 	

    61 	test(i);

    62 	test.Printf(_L("\nFLogger Server Shutdown after %d secs\n"), 29-i);

    63 	}

    64 

    65 LOCAL_C TInt DeleteFolder(const TDesC& aFolder)

    66 	{

    67 

    68 	TUint temp;

    69 	_LIT(KLogDir,"c:\\Logs\\");

    70 	TInt ret=fs.Att(KLogDir,temp);

    71 	if (ret==KErrPathNotFound)

    72 		return KErrNone;

    73 	else

    74 		{

    75 		TInt exists=fs.Att(aFolder,temp);

    76 		if (exists==KErrPathNotFound)

    77 			return KErrNone;

    78 		

    79 		if (exists!=KErrNotFound)

    80 			{

    81 			TFileName file1=aFolder;

    82 			file1.Append(KTestLogFileName1);

    83 			ret=fs.Delete(file1);

    84 			if (ret!=KErrNone && ret!=KErrNotFound)

    85 				return ret;

    86 			TFileName file2=aFolder;

    87 			file2.Append(KTestLogFileName1);

    88 			ret=fs.Delete(file2);

    89 			if (ret!=KErrNone && ret!=KErrNotFound)

    90 				return ret;

    91 			}

    92 

    93 		CFileMan* fileman=NULL;

    94 		TRAP(ret,fileman=CFileMan::NewL(fs));

    95 		TFileName folder;

    96 		folder.Copy(aFolder.Left(aFolder.Length()-1));

    97 		ret=fileman->RmDir(folder);

    98 		delete fileman;

    99 		return ret;

   100 		}

   101 	}

   102 

   103 LOCAL_C void CreateFolderL(const TDesC& aFolder)

   104 	{

   105 

   106 	TInt ret=fs.MkDirAll(aFolder);

   107 	if (ret!=KErrNone && ret!=KErrAlreadyExists)

   108 		User::Leave(ret);

   109 	}

   110 

   111 LOCAL_C void WriteToLog(RFileLogger& aLog)

   112 	{

   113 

   114 	// 16 bit writes

   115 	TUint num1=100;

   116 	aLog.WriteFormat(_L("Writing a number to the log: %d"),num1);

   117 	test(aLog.LastError()==KErrNone);

   118 	TUint num2=200;

   119 	aLog.WriteFormat(_L("Writing two numbers to the log: %d, %d"),num1,num2);

   120 	test(aLog.LastError()==KErrNone);

   121 	aLog.SetDateAndTime(ETrue,ETrue);

   122 	aLog.Write(_L("Line should begin with date and time"));

   123 	test(aLog.LastError()==KErrNone);

   124 	aLog.SetDateAndTime(ETrue,EFalse);

   125 	aLog.Write(_L("Line should begin with date only"));

   126 	test(aLog.LastError()==KErrNone);

   127 	aLog.SetDateAndTime(EFalse,ETrue);

   128 	aLog.Write(_L("Line should begin with time only"));

   129 	test(aLog.LastError()==KErrNone);

   130 	aLog.SetDateAndTime(EFalse,EFalse);

   131 	aLog.Write(_L("Line should begin with nothing"));

   132 	test(aLog.LastError()==KErrNone);

   133 	aLog.Write(_L(""));

   134 	test(aLog.LastError()==KErrNone);

   135 	aLog.Write(_L("There should be a blank line above and below this one"));

   136 	test(aLog.LastError()==KErrNone);

   137 	aLog.Write(_L(""));

   138 	test(aLog.LastError()==KErrNone);

   139 

   140 	// 8 bit writes

   141 	aLog.WriteFormat(_L8("Writing a number to the log: %d"),num1);

   142 	test(aLog.LastError()==KErrNone);

   143 	aLog.WriteFormat(_L8("Writing two numbers to the log: %d, %d"),num1,num2);

   144 	test(aLog.LastError()==KErrNone);

   145 	aLog.SetDateAndTime(ETrue,ETrue);

   146 	aLog.Write(_L8("Line should begin with date and time"));

   147 	test(aLog.LastError()==KErrNone);

   148 	aLog.SetDateAndTime(ETrue,EFalse);

   149 	aLog.Write(_L8("Line should begin with date only"));

   150 	test(aLog.LastError()==KErrNone);

   151 	aLog.SetDateAndTime(EFalse,ETrue);

   152 	aLog.Write(_L8("Line should begin with time only"));

   153 	test(aLog.LastError()==KErrNone);

   154 	aLog.SetDateAndTime(EFalse,EFalse);

   155 	aLog.Write(_L8("Line should begin with nothing"));

   156 	test(aLog.LastError()==KErrNone);

   157 	aLog.Write(_L8(""));

   158 	test(aLog.LastError()==KErrNone);

   159 	aLog.Write(_L8("There should be a blank line above and below this one"));

   160 	test(aLog.LastError()==KErrNone);

   161 	aLog.Write(_L8(""));

   162 	test(aLog.LastError()==KErrNone);

   163 

   164 // 2.2.1.5 Dump hexadecimal values

   165 	// Hex dump

   166 	const TText* hdr=_S("123456");

   167 	const TText* mgn=_S("      ");

   168 	const TUint8* ptr=_S8("abcdefghijklmnopqrstuvwxyz");

   169 	TInt len=26;

   170 	aLog.HexDump(hdr, mgn, ptr, len);

   171 	test(aLog.LastError()==KErrNone);

   172 	aLog.HexDump(NULL, mgn, ptr, len);

   173 	test(aLog.LastError()==KErrNone);

   174 	aLog.HexDump(hdr, NULL, ptr, len);

   175 	test(aLog.LastError()==KErrNone);

   176 	aLog.HexDump(hdr, mgn, NULL, len);

   177 	test(aLog.LastError()==KErrNone);

   178 	aLog.SetDateAndTime(ETrue,ETrue);

   179 	aLog.HexDump(hdr, mgn, ptr, len);

   180 	test(aLog.LastError()==KErrNone);

   181 	aLog.HexDump(NULL, mgn, ptr, len);

   182 	test(aLog.LastError()==KErrNone);

   183 	aLog.HexDump(hdr, NULL, ptr, len);

   184 	test(aLog.LastError()==KErrNone);

   185 	aLog.HexDump(hdr, mgn, NULL, len);	

   186 	test(aLog.LastError()==KErrNone);

   187 	}

   188 

   189 // 2.2.1 Writing to two open log files at a time 

   190 // 2.2.1.3 Files are different 

   191 LOCAL_C void testTwoClientsL(TBool aValid)

   192 	{

   193 

   194 	if (!aValid)

   195 		test(DeleteFolder(KTestLogFullDir1)==KErrNone);

   196 	else

   197 		CreateFolderL(KTestLogFullDir1);

   198 

   199 	RFileLogger log1;

   200 	test(log1.Connect()==KErrNone);

   201 	RFileLogger log2;

   202 	test(log2.Connect()==KErrNone);

   203 

   204 	log1.CreateLog(KTestLogDir1,KTestLogFileName1,EFileLoggingModeOverwrite);

   205 	test(log1.LastError()==KErrNone);

   206 	test(log1.LogValid()==aValid);

   207 	

   208 	log2.CreateLog(KTestLogDir1,KTestLogFileName2,EFileLoggingModeOverwrite);

   209 	test(log2.LastError()==KErrNone);

   210 	test(log2.LogValid()==aValid);

   211 	

   212 	log1.Write(_L("This is written to log 1"));

   213 	test(log1.LastError()==KErrNone);

   214 	test(log1.LogValid()==aValid);

   215 	log2.Write(_L("This is written to log 2"));

   216 	test(log2.LastError()==KErrNone);

   217 	test(log2.LogValid()==aValid);

   218 

   219 	WriteToLog(log1);

   220 	WriteToLog(log2);

   221 

   222 	log1.CloseLog();

   223 	log2.CloseLog();

   224 

   225 	TUint temp;

   226 	if (aValid)

   227 		{

   228 		test(fs.Att(KTestLogFile1,temp)==KErrNone);

   229 		test(fs.Att(KTestLogFile2,temp)==KErrNone);

   230 		}

   231 	else

   232 		{

   233 		test(fs.Att(KTestLogFile1,temp)==KErrPathNotFound);

   234 		test(fs.Att(KTestLogFile2,temp)==KErrPathNotFound);

   235 		}

   236 

   237 	log1.Close();

   238 	log2.Close();

   239 	}

   240 

   241 // 2.2.2 Static appends 

   242 LOCAL_C void testStaticWrites(TBool aValid)

   243 	{

   244 	

   245 	if (!aValid)

   246 		test(DeleteFolder(KTestLogFullDir2)==KErrNone);

   247 	else

   248 		{

   249 		TRAPD(ret,(CreateFolderL(KTestLogFullDir2)));

   250 		test(ret==KErrNone);

   251 		}

   252 

   253 	RFileLogger::Write(KTestLogDir2,KTestLogFileName1,EFileLoggingModeAppend,_L("Writing to the log"));

   254 	TUint num1=100;

   255 	RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L("Writing a number to the log: %d"),num1);

   256 	TUint num2=200;

   257 	RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L("Writing two numbers to the log: %d, %d"),num1,num2);

   258 

   259 	RFileLogger::Write(KTestLogDir2,KTestLogFileName1,EFileLoggingModeAppend,_L8("Writing to the log"));

   260 	RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L8("Writing a number to the log: %d"),num1);

   261 	RFileLogger::WriteFormat(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend,_L8("Writing two numbers to the log: %d, %d"),num1,num2);

   262 

   263 	const TText* hdr=_S("123456");

   264 	const TText* mgn=_S("      ");

   265 	const TUint8* ptr=_S8("abcdefghijklmnopqrstuvwxyz");

   266 	TInt len=26;

   267 	RFileLogger::HexDump(KTestLogDir2(),KTestLogFileName1(),EFileLoggingModeAppend, hdr, mgn, ptr, len);

   268 		

   269 	TUint temp;

   270 	if (aValid)

   271 		test(fs.Att(KTestLogFile3,temp)==KErrNone);

   272 	else

   273 		test(fs.Att(KTestLogFile3,temp)==KErrPathNotFound);

   274 	}

   275 

   276 // 2.2.1 Writing to two open log files at a time 

   277 // 2.2.1.4 Files are the same 

   278 LOCAL_C void testTwoClientsOneFileL(TBool aValid)

   279 	{

   280 

   281 	if (!aValid)

   282 		test(DeleteFolder(KTestLogFullDir3)==KErrNone);

   283 	else

   284 		CreateFolderL(KTestLogFullDir3);

   285 

   286 	RFileLogger log1;

   287 	test(log1.Connect()==KErrNone);

   288 	RFileLogger log2;

   289 	test(log2.Connect()==KErrNone);

   290 

   291 	log1.CreateLog(KTestLogDir3,KTestLogFileName1,EFileLoggingModeOverwrite);

   292 	test(log1.LastError()==KErrNone);

   293 	test(log1.LogValid()==aValid);

   294 	

   295 	log2.CreateLog(KTestLogDir3,KTestLogFileName1,EFileLoggingModeOverwrite);

   296 	test(log2.LastError()==KErrNone);

   297 	test(log2.LogValid()==aValid);

   298 	

   299 	log1.Write(_L("This is written from log session 1"));

   300 	test(log1.LastError()==KErrNone);

   301 	test(log1.LogValid()==aValid);

   302 	log2.Write(_L("This is written from log session 2"));

   303 	test(log2.LastError()==KErrNone);

   304 	test(log2.LogValid()==aValid);

   305 

   306 	WriteToLog(log1);

   307 	WriteToLog(log2);

   308 

   309 	log1.CloseLog();

   310 	log2.CloseLog();

   311 

   312 	TUint temp;

   313 	if (aValid)

   314 		test(fs.Att(KTestLogFile4,temp)==KErrNone);

   315 	else

   316 		test(fs.Att(KTestLogFile4,temp)==KErrPathNotFound);

   317 

   318 	log1.Close();

   319 	log2.Close();

   320 	}

   321 

   322 // 2.2.4 Invalid operations

   323 //

   324 // Check that buffers larger than KLogBufferSize can be written without error.

   325 LOCAL_C void testInvalidOps1L()

   326 	{

   327 

   328 	CreateFolderL(KTestLogFullDir4);

   329 

   330 	RFileLogger log;

   331 	test(log.Connect()==KErrNone);

   332 

   333 	log.CreateLog(KTestLogDir4,KTestLogFileName1,EFileLoggingModeOverwrite);

   334 	test(log.LastError()==KErrNone);

   335 	test(log.LogValid());

   336 

   337 	TBuf<151> longBuf;

   338 	TChar ch('X');

   339 	longBuf.Fill(ch,151);

   340 	test(longBuf.Length()==151);

   341 	log.Write(longBuf);					// only those chars which will fit will be written

   342 	test(log.LastError()==KErrNone);

   343 

   344 	TBuf8<151> longBuf8;

   345 	longBuf8.Fill(ch,151);

   346 	test(longBuf8.Length()==151);

   347 	log.Write(longBuf8);				// only those chars which will fit will be written

   348 	test(log.LastError()==KErrNone);

   349 

   350 	log.Close();

   351 	}

   352 	

   353 // Check that overlong directory names as well as file names cause an overflow error.

   354 LOCAL_C void testInvalidOps2L()

   355 	{

   356 

   357 	CreateFolderL(KTestLogFullDir4);

   358 

   359 	RFileLogger log;

   360 	test(log.Connect()==KErrNone);

   361 

   362 	TFileName dirName, fileName;

   363 	dirName.SetLength(dirName.MaxLength());

   364 	log.CreateLog(dirName,KTestLogFileName1,EFileLoggingModeOverwrite);

   365 	test(log.LastError()==KErrOverflow);

   366 

   367 	fileName.SetLength(fileName.MaxLength());

   368 	log.CreateLog(KTestLogDir1,fileName,EFileLoggingModeOverwrite);

   369 	test(log.LastError()==KErrOverflow);

   370 

   371 	log.Close();

   372 	}

   373 

   374 // 2.2.3 Access counting 

   375 LOCAL_C void TestAccessCountingL(TBool aValid)

   376 	{

   377 

   378 	if (aValid)

   379 		CreateFolderL(KTestLogFullDir5);

   380 	else

   381 		DeleteFolder(KTestLogFullDir5);

   382 

   383 	RFileLogger log;

   384 	test(log.Connect()==KErrNone);

   385 

   386 	log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite);

   387 	test(log.LastError()==KErrNone);

   388 

   389 	log.CloseLog();

   390 

   391 	log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite);

   392 	test(log.LastError()==KErrNone);

   393 

   394 	log.CloseLog();

   395 

   396 	log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite);

   397 	test(log.LastError()==KErrNone);

   398 

   399 	log.Close();

   400 

   401 // Test closing log twice

   402 

   403 	test(log.Connect()==KErrNone);

   404 

   405 	log.CreateLog(KTestLogDir5,KTestLogFileName1,EFileLoggingModeOverwrite);

   406 	test(log.LastError()==KErrNone);

   407 

   408 	log.CloseLog();

   409 	log.CloseLog();			// timer will be running if file exists

   410 	User::After(6000000);

   411 	log.CloseLog();			// timer will have expired

   412 	log.Close();

   413 

   414 // Test closing session twice

   415 

   416 	test(log.Connect()==KErrNone);

   417 

   418 	log.Close();

   419 	log.Close();			// timer will be running

   420 	TestWaitForShutDown();

   421 	log.Close();			// timer will have expired

   422 	}

   423 

   424 LOCAL_C void doExampleL()

   425 	{

   426 

   427 	User::LeaveIfError(fs.Connect());

   428 

   429 	// delete all files and folders

   430 	DeleteFolder(KTestLogFullDir1);	// ignore return value

   431 	DeleteFolder(KTestLogFullDir2);	// ignore return value

   432 	DeleteFolder(KTestLogFullDir3);	// ignore return value

   433 	DeleteFolder(KTestLogFullDir4);

   434 

   435 	test.Printf(_L("\nDo tests with Folders not existing....\n"));

   436 

   437 	test.Start(_L("Two Sessions logging to different files: PDS-FILELOGGER-UT-4001"));

   438 	testTwoClientsL(EFalse);	// folders do not exist

   439 	

   440 	test.Next(_L("Two sessions logging to one file: PDS-FILELOGGER-UT-4002"));

   441 	testTwoClientsOneFileL(EFalse);		// folders do not exist

   442 	

   443 	test.Next(_L("Static logging: PDS-FILELOGGER-UT-4003"));

   444 	testStaticWrites(EFalse);		// folders do not exist

   445 

   446 	test.Next(_L("Test Closing and Access Counting: PDS-FILELOGGER-UT-4004"));

   447 	TestAccessCountingL(EFalse);

   448 

   449 	test.Printf(_L("\nDo tests with Folders existing....\n"));

   450 

   451 	test.Start(_L("Two Sessions logging to different files: PDS-FILELOGGER-UT-4001"));

   452 	testTwoClientsL(ETrue);		// folders exist

   453 

   454 	test.Next(_L("Two sessions logging to one file: PDS-FILELOGGER-UT-4002"));

   455 	testTwoClientsOneFileL(ETrue);		// folders exist

   456 

   457 	test.Next(_L("Static logging: PDS-FILELOGGER-UT-4003"));

   458 	testStaticWrites(ETrue);		// folders exist

   459 

   460 	test.Next(_L("Invalid Operations: PDS-FILELOGGER-UT-4005"));

   461 	testInvalidOps1L();

   462 	test.Next(_L("Invalid Operations: PDS-FILELOGGER-UT-4006"));

   463 	testInvalidOps2L();

   464 

   465 	test.Next(_L("Test Closing and Access Counting: PDS-FILELOGGER-UT-4004"));

   466 	TestAccessCountingL(ETrue);

   467 

   468 	RFileLogger log;

   469 	test(log.Connect()==KErrNone);

   470 	log.Close();

   471 

   472 	TestWaitForShutDown();

   473 	test.End();

   474 

   475 	fs.Close();

   476 	}

   477 

   478 GLDEF_C TInt E32Main()

   479 	{

   480 

   481 	CTrapCleanup* cleanup=CTrapCleanup::New();

   482 

   483 	__UHEAP_MARK;

   484 	

   485 	test.Title();

   486 

   487 	TRAPD(ret,doExampleL());

   488 	test(ret==KErrNone);

   489 	

   490     test.End();

   491 	test.Close();

   492 

   493 	__UHEAP_MARKEND;

   494 

   495 	delete cleanup;

   496 	User::Heap().Check();

   497 	return KErrNone;

   498 	}