Mercurial Mercurial > oss > MCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kerneltest/f32test/server/t_dspace.cpp
branchRCL_3
changeset 43 c1f20ce4abcf
parent 42 a179b74831c9
child 44 3e88ff8f41d5
equal deleted inserted replaced
42:a179b74831c9 43:c1f20ce4abcf 
    13 // Description:
 
    13 // Description:
 
    14 // f32test\server\t_dspace.cpp
 
    14 // f32test\server\t_dspace.cpp
 
    15 //
 
    15 //
 
    16 //
 
    16 //
 
    17 
    17 
       
    18 #define __E32TEST_EXTENSION__
 
    18 #include <f32file.h>
 
    19 #include <f32file.h>
 
    19 #include <e32test.h>
 
    20 #include <e32test.h>
 
    20 #include "t_server.h"
 
    21 #include "t_server.h"
 
    21 #include "t_chlffs.h"
 
    22 #include "t_chlffs.h"
 
    22 
    23 
   102 //
 
   103 //
 
   103 //
 
   104 //
 
   104 	{
 
   105 	{
 
   105 	TVolumeInfo v;
 
   106 	TVolumeInfo v;
 
   106 	TInt r=TheFs.Volume(v,aDrive);
 
   107 	TInt r=TheFs.Volume(v,aDrive);
 
   107 	test(r==KErrNone);
 
   108 	test_KErrNone(r);
 
   108 	return(v.iFree);
 
   109 	return(v.iFree);
 
   109 	}
 
   110 	}
 
   110 
   111 
   111 LOCAL_C TInt64 DiskSize(TInt aDrive)
 
   112 LOCAL_C TInt64 DiskSize(TInt aDrive)
 
   112 //
 
   113 //
 
   113 //
 
   114 //
 
   114 //
 
   115 //
 
   115 	{
 
   116 	{
 
   116 	TVolumeInfo v;
 
   117 	TVolumeInfo v;
 
   117 	TInt r=TheFs.Volume(v,aDrive);
 
   118 	TInt r=TheFs.Volume(v,aDrive);
 
   118 	test(r==KErrNone);
 
   119 	test_KErrNone(r);
 
   119 	return(v.iSize);
 
   120 	return(v.iSize);
 
   120 	}
 
   121 	}
 
   121 
   122 
   122 // MinimumFileSize() -
 
   123 // MinimumFileSize() -
 
   123 // Deduces the minimum space occupied by a file by creating a file of one byte
 
   124 // Deduces the minimum space occupied by a file by creating a file of one byte
 
   124 // in length. This should equal the cluster size on FAT volumes.
 
   125 // in length. This should equal the cluster size on FAT volumes.
 
   125 //
 
   126 //
 
   126 LOCAL_C TInt MinimumFileSize(TInt aDrive)
 
   127 LOCAL_C TInt MinimumFileSize(TInt aDrive)
 
   127 	{
 
   128 	{
 
   128 	TInt r = TheFs.Delete(KTestFile1);
 
   129 	TInt r = TheFs.Delete(KTestFile1);
 
   129 	test(r==KErrNone || r==KErrNotFound);
 
   130 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   130 
   131 
   131 	TInt64 freeSpace = FreeDiskSpace(aDrive);
 
   132 	TInt64 freeSpace = FreeDiskSpace(aDrive);
 
   132 
   133 
   133 	RFile file;
 
   134 	RFile file;
 
   134 
   135 
   135 
   136 
   136 	r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   137 	r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   137 	test(r==KErrNone);
 
   138 	test_KErrNone(r);
 
   138 
   139 
   139 	r = file.Write(TheBuffer,1);
 
   140 	r = file.Write(TheBuffer,1);
 
   140 	test(r==KErrNone);
 
   141 	test_KErrNone(r);
 
   141 	file.Close();
 
   142 	file.Close();
 
   142 	TInt64 newSpace = FreeDiskSpace(aDrive);
 
   143 	TInt64 newSpace = FreeDiskSpace(aDrive);
 
   143 
   144 
   144 	r = TheFs.Delete(KTestFile1);
 
   145 	r = TheFs.Delete(KTestFile1);
 
   145 	test(r==KErrNone);
 
   146 	test_KErrNone(r);
 
   146 
   147 
   147 
   148 
   148 	TInt64 minFileSize = freeSpace - newSpace;
 
   149 	TInt64 minFileSize = freeSpace - newSpace;
 
   149 	test (minFileSize >= 0);
 
   150 	test (minFileSize >= 0);
 
   150 	minFileSize = Max(minFileSize, 512);
 
   151 	minFileSize = Max(minFileSize, 512);
 
   214 	test.Printf(_L("inside init++++++++++++++++++++++++++>\n\n\n"));
 
   215 	test.Printf(_L("inside init++++++++++++++++++++++++++>\n\n\n"));
 
   215 	test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive);
 
   216 	test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive);
 
   216 	// initialise removable drive descriptor
 
   217 	// initialise removable drive descriptor
 
   217 	TChar c;
 
   218 	TChar c;
 
   218 	TInt r=RFs::DriveToChar(RemovableDrive,c);
 
   219 	TInt r=RFs::DriveToChar(RemovableDrive,c);
 
   219 	test(r==KErrNone);
 
   220 	test_KErrNone(r);
 
   220 	RemovableDriveBuf[0]=(TText)c;
 
   221 	RemovableDriveBuf[0]=(TText)c;
 
   221 
   222 
   222 	if( !LffsDrive )
 
   223 	if( !LffsDrive )
 
   223 		{
 
   224 		{
 
   224 		// and create the default directory
 
   225 		// and create the default directory
 
   228 		}
 
   229 		}
 
   229 
   230 
   230 	// better format the default drive as long as not WINS c drive
 
   231 	// better format the default drive as long as not WINS c drive
 
   231 	TInt drive;
 
   232 	TInt drive;
 
   232 	r= RFs::CharToDrive(gSessionPath[0],drive);
 
   233 	r= RFs::CharToDrive(gSessionPath[0],drive);
 
   233 	test(r==KErrNone);
 
   234 	test_KErrNone(r);
 
   234 #if defined(__WINS__)
 
   235 #if defined(__WINS__)
 
   235 	if(drive!=EDriveC)
 
   236 	if(drive!=EDriveC)
 
   236 		Format(drive);
 
   237 		Format(drive);
 
   237 #else
 
   238 #else
 
   238 	Format(drive);
 
   239 	Format(drive);
 
   240 	Format(EDriveC);
 
   241 	Format(EDriveC);
 
   241 #endif
 
   242 #endif
 
   242 	TheDiskSize=DiskSize(KDefaultDrive);
 
   243 	TheDiskSize=DiskSize(KDefaultDrive);
 
   243 	// and set the default directory
 
   244 	// and set the default directory
 
   244 	r=TheFs.MkDirAll(gSessionPath);
 
   245 	r=TheFs.MkDirAll(gSessionPath);
 
   245 	test(r==KErrNone || r==KErrAlreadyExists);
 
   246 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   246 
   247 
   247 	r=TheFs.Delete(KFileFiller);
 
   248 	r=TheFs.Delete(KFileFiller);
 
   248 	test(r==KErrNone || r==KErrNotFound);
 
   249 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   249 	r=TheFs.Delete(KTestFile1);
 
   250 	r=TheFs.Delete(KTestFile1);
 
   250 	test(r==KErrNone || r==KErrNotFound);
 
   251 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   251 	r=TheFs.Delete(KTestFile2);
 
   252 	r=TheFs.Delete(KTestFile2);
 
   252 	test(r==KErrNone || r==KErrNotFound);
 
   253 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   253 	r=TheFs.RmDir(KTestDir1);
 
   254 	r=TheFs.RmDir(KTestDir1);
 
   254 	test(r==KErrNone || r==KErrNotFound);
 
   255 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   255 	r=TheFs.RmDir(KTestDir2);
 
   256 	r=TheFs.RmDir(KTestDir2);
 
   256 	test(r==KErrNone || r==KErrNotFound);
 
   257 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   257 
   258 
   258 	gMinFileSize = MinimumFileSize(drive);
 
   259 	gMinFileSize = MinimumFileSize(drive);
 
   259 	}
 
   260 	}
 
   260 
   261 
   261 LOCAL_C TInt64 FillDisk(RFile& aFile,TInt64 aNewSpace,TInt aDrive)
 
   262 LOCAL_C TInt64 FillDisk(RFile& aFile,TInt64 aNewSpace,TInt aDrive)
 
   269 		{
 
   270 		{
 
   270 		TInt s=Min(KMaxBufSize, I64INT(space-aNewSpace));
 
   271 		TInt s=Min(KMaxBufSize, I64INT(space-aNewSpace));
 
   271 		TInt r=aFile.Write(TheBuffer,s);
 
   272 		TInt r=aFile.Write(TheBuffer,s);
 
   272 		if( !LffsDrive )
 
   273 		if( !LffsDrive )
 
   273 			{
 
   274 			{
 
   274 			test(r==KErrNone);
 
   275 			test_KErrNone(r);
 
   275 			}
 
   276 			}
 
   276 		else
 
   277 		else
 
   277 			{
 
   278 			{
 
   278 			//
 
   279 			//
 
   279 			// LFFS is less predictable than a normal drive because of the logging
 
   280 			// LFFS is less predictable than a normal drive because of the logging
 
   324 		if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 
   325 		if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 
   325 			r = aFile.Flush();
 
   326 			r = aFile.Flush();
 
   326 
   327 
   327 		if( !LffsDrive )
 
   328 		if( !LffsDrive )
 
   328 			{
 
   329 			{
 
   329 			test(r==KErrNone);
 
   330 			test_KErrNone(r);
 
   330 			}
 
   331 			}
 
   331 		else
 
   332 		else
 
   332 			{
 
   333 			{
 
   333 			// we can't accurately predict the amount of data we can actually get
 
   334 			// we can't accurately predict the amount of data we can actually get
 
   334 			// on an LFFS drive, so it's posible we could exceed the available
 
   335 			// on an LFFS drive, so it's posible we could exceed the available
 
   351 	TInt r;
 
   352 	TInt r;
 
   352 	switch(aTask)
 
   353 	switch(aTask)
 
   353 		{
 
   354 		{
 
   354 		case ETaskMkDir:
 
   355 		case ETaskMkDir:
 
   355 			r=TheFs.RmDir(KTestDir1);
 
   356 			r=TheFs.RmDir(KTestDir1);
 
   356 			test(r==KErrNone);
 
   357 			test_KErrNone(r);
 
   357 			break;
 
   358 			break;
 
   358 		case ETaskRmDir: break;
 
   359 		case ETaskRmDir: break;
 
   359 		case ETaskDelete: break;
 
   360 		case ETaskDelete: break;
 
   360 		case ETaskReplace:
 
   361 		case ETaskReplace:
 
   361 			r=TheFs.Delete(KTestFile2);
 
   362 			r=TheFs.Delete(KTestFile2);
 
   362 			test(r==KErrNone);
 
   363 			test_KErrNone(r);
 
   363 			break;
 
   364 			break;
 
   364 		case ETaskFileReplace:
 
   365 		case ETaskFileReplace:
 
   365 			r=TheFs.Delete(KTestFile1);
 
   366 			r=TheFs.Delete(KTestFile1);
 
   366 			test(r==KErrNone);
 
   367 			test_KErrNone(r);
 
   367 			break;
 
   368 			break;
 
   368 		case ETaskFileWrite:
 
   369 		case ETaskFileWrite:
 
   369 		case ETaskFileWrite4KB:
 
   370 		case ETaskFileWrite4KB:
 
   370 		case ETaskFileWrite64KB:
 
   371 		case ETaskFileWrite64KB:
 
   371 		case ETaskFileSetSize:
 
   372 		case ETaskFileSetSize:
 
   394 	switch(aTask)
 
   395 	switch(aTask)
 
   395 		{
 
   396 		{
 
   396 		case ETaskMkDir:	break;
 
   397 		case ETaskMkDir:	break;
 
   397 		case ETaskRmDir:
 
   398 		case ETaskRmDir:
 
   398 			r=TheFs.MkDir(KTestDir1);
 
   399 			r=TheFs.MkDir(KTestDir1);
 
   399 			test(r==KErrNone);
 
   400 			test_KErrNone(r);
 
   400 			break;
 
   401 			break;
 
   401 		case ETaskDelete:
 
   402 		case ETaskDelete:
 
   402 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   403 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   403 			test(r==KErrNone);
 
   404 			test_KErrNone(r);
 
   404 			if( !LffsDrive )
 
   405 			if( !LffsDrive )
 
   405 				{
 
   406 				{
 
   406 				r=file.SetSize(KFileSize1);
 
   407 				r=file.SetSize(KFileSize1);
 
   407 				test(r==KErrNone);
 
   408 				test_KErrNone(r);
 
   408 				}
 
   409 				}
 
   409 			else
 
   410 			else
 
   410 				{
 
   411 				{
 
   411 				// LFFS supports sparse files, so we have to write real data
 
   412 				// LFFS supports sparse files, so we have to write real data
 
   412 				// into the file to ensure that it uses up disk space
 
   413 				// into the file to ensure that it uses up disk space
 
   414 				}
 
   415 				}
 
   415 			file.Close();
 
   416 			file.Close();
 
   416 			break;
 
   417 			break;
 
   417 		case ETaskReplace:
 
   418 		case ETaskReplace:
 
   418 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   419 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   419 			test(r==KErrNone);
 
   420 			test_KErrNone(r);
 
   420 			if( !LffsDrive )
 
   421 			if( !LffsDrive )
 
   421 				{
 
   422 				{
 
   422 				r=file.SetSize(KFileSize1);
 
   423 				r=file.SetSize(KFileSize1);
 
   423 				test(r==KErrNone);
 
   424 				test_KErrNone(r);
 
   424 				}
 
   425 				}
 
   425 			else
 
   426 			else
 
   426 				{
 
   427 				{
 
   427 				WriteToFile( file, KFileSize2 );
 
   428 				WriteToFile( file, KFileSize2 );
 
   428 				}
 
   429 				}
 
   429 			file.Close();
 
   430 			file.Close();
 
   430 			r=file2.Create(TheFs,KTestFile2,EFileShareAny|EFileWrite);
 
   431 			r=file2.Create(TheFs,KTestFile2,EFileShareAny|EFileWrite);
 
   431 			test(r==KErrNone);
 
   432 			test_KErrNone(r);
 
   432 			if( !LffsDrive )
 
   433 			if( !LffsDrive )
 
   433 				{
 
   434 				{
 
   434 				r=file2.SetSize(KFileSize3);
 
   435 				r=file2.SetSize(KFileSize3);
 
   435 				test(r==KErrNone);
 
   436 				test_KErrNone(r);
 
   436 				}
 
   437 				}
 
   437 			else
 
   438 			else
 
   438 				{
 
   439 				{
 
   439 				WriteToFile( file2, gMinFileSize << 4);	// 512 * 16 = 8K
 
   440 				WriteToFile( file2, gMinFileSize << 4);	// 512 * 16 = 8K
 
   440 				}
 
   441 				}
 
   441 			file2.Close();
 
   442 			file2.Close();
 
   442 			break;
 
   443 			break;
 
   443 		case ETaskFileReplace:
 
   444 		case ETaskFileReplace:
 
   444 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   445 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   445 			test(r==KErrNone);
 
   446 			test_KErrNone(r);
 
   446 			if( !LffsDrive )
 
   447 			if( !LffsDrive )
 
   447 				{
 
   448 				{
 
   448 				r=file.SetSize(KFileSize3*2);
 
   449 				r=file.SetSize(KFileSize3*2);
 
   449 				}
 
   450 				}
 
   450 			else
 
   451 			else
 
   451 				{
 
   452 				{
 
   452 				WriteToFile( file, KFileSize3 );
 
   453 				WriteToFile( file, KFileSize3 );
 
   453 				}
 
   454 				}
 
   454 			test(r==KErrNone);
 
   455 			test_KErrNone(r);
 
   455 			file.Close();
 
   456 			file.Close();
 
   456 			break;
 
   457 			break;
 
   457 		case ETaskFileWrite:
 
   458 		case ETaskFileWrite:
 
   458 		case ETaskFileWrite4KB:
 
   459 		case ETaskFileWrite4KB:
 
   459 		case ETaskFileWrite64KB:
 
   460 		case ETaskFileWrite64KB:
 
   460 		case ETaskFileSetSize:
 
   461 		case ETaskFileSetSize:
 
   461 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   462 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   462 			test(r==KErrNone);
 
   463 			test_KErrNone(r);
 
   463 			file.Close();
 
   464 			file.Close();
 
   464 			break;
 
   465 			break;
 
   465 		case ETaskNoChange1:
 
   466 		case ETaskNoChange1:
 
   466 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   467 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   467 			test(r==KErrNone);
 
   468 			test_KErrNone(r);
 
   468 			if( !LffsDrive )
 
   469 			if( !LffsDrive )
 
   469 				{
 
   470 				{
 
   470 				r=file.SetSize(KFileSize1);
 
   471 				r=file.SetSize(KFileSize1);
 
   471 				test(r==KErrNone);
 
   472 				test_KErrNone(r);
 
   472 				}
 
   473 				}
 
   473 			else
 
   474 			else
 
   474 				{
 
   475 				{
 
   475 				WriteToFile( file, KFileSize1 );
 
   476 				WriteToFile( file, KFileSize1 );
 
   476 				}
 
   477 				}
 
   477 			file.Close();
 
   478 			file.Close();
 
   478 			break;
 
   479 			break;
 
   479 		case ETaskNoChange2:
 
   480 		case ETaskNoChange2:
 
   480 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   481 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
   481 			test(r==KErrNone);
 
   482 			test_KErrNone(r);
 
   482 			file.Close();
 
   483 			file.Close();
 
   483 			break;
 
   484 			break;
 
   484 		case ETaskFileCreateLffs:
 
   485 		case ETaskFileCreateLffs:
 
   485 			r = TheFs.Delete(KTestFile1);
 
   486 			r = TheFs.Delete(KTestFile1);
 
   486 			break;
 
   487 			break;
 
   495 //
 
   496 //
 
   496 	{
 
   497 	{
 
   497 	RTest test(_L("T_DSPACE_ThreadFunction"));
 
   498 	RTest test(_L("T_DSPACE_ThreadFunction"));
 
   498 	RFs fs;
 
   499 	RFs fs;
 
   499 	TInt r=fs.Connect();
 
   500 	TInt r=fs.Connect();
 
   500 	test(r==KErrNone);
 
   501 	test_KErrNone(r);
 
   501 	r=fs.SetSessionPath(gSessionPath);
 
   502 	r=fs.SetSessionPath(gSessionPath);
 
   502 	test(r==KErrNone);
 
   503 	test_KErrNone(r);
 
   503 	TThreadTask task=*(TThreadTask*)&aThreadTask;
 
   504 	TThreadTask task=*(TThreadTask*)&aThreadTask;
 
   504 	RFile file;
 
   505 	RFile file;
 
   505 	switch(task)
 
   506 	switch(task)
 
   506 		{
 
   507 		{
 
   507 		case ETaskMkDir:
 
   508 		case ETaskMkDir:
 
   508 			r=fs.MkDir(KTestDir1);
 
   509 			r=fs.MkDir(KTestDir1);
 
   509 			test(r==KErrNone);
 
   510 			test_KErrNone(r);
 
   510 			break;
 
   511 			break;
 
   511 		case ETaskRmDir:
 
   512 		case ETaskRmDir:
 
   512 			r=fs.RmDir(KTestDir1);
 
   513 			r=fs.RmDir(KTestDir1);
 
   513 			test(r==KErrNone);
 
   514 			test_KErrNone(r);
 
   514 			break;
 
   515 			break;
 
   515 		case ETaskDelete:
 
   516 		case ETaskDelete:
 
   516 			r=fs.Delete(KTestFile1);
 
   517 			r=fs.Delete(KTestFile1);
 
   517 			test(r==KErrNone);
 
   518 			test_KErrNone(r);
 
   518 			break;
 
   519 			break;
 
   519 		case ETaskReplace:
 
   520 		case ETaskReplace:
 
   520 			r=fs.Replace(KTestFile1,KTestFile2);
 
   521 			r=fs.Replace(KTestFile1,KTestFile2);
 
   521 			test(r==KErrNone);
 
   522 			test_KErrNone(r);
 
   522 			break;
 
   523 			break;
 
   523 		case ETaskFileReplace:
 
   524 		case ETaskFileReplace:
 
   524 			r=file.Replace(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   525 			r=file.Replace(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   525 			test(r==KErrNone);
 
   526 			test_KErrNone(r);
 
   526 			file.Close();
 
   527 			file.Close();
 
   527 			break;
 
   528 			break;
 
   528 		case ETaskFileWrite:
 
   529 		case ETaskFileWrite:
 
   529 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   530 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   530 			test(r==KErrNone);
 
   531 			test_KErrNone(r);
 
   531 #if defined(__WINS__)
 
   532 #if defined(__WINS__)
 
   532 			WriteToFile( file, gMinFileSize << 4);	// 512 * 16 = 8K
 
   533 			WriteToFile( file, gMinFileSize << 4);	// 512 * 16 = 8K
 
   533 #else
 
   534 #else
 
   534 			WriteToFile( file, gMinFileSize << 1);	// 512 * 2 = 1K
 
   535 			WriteToFile( file, gMinFileSize << 1);	// 512 * 2 = 1K
 
   535 #endif
 
   536 #endif
 
   536 			file.Close();
 
   537 			file.Close();
 
   537 			break;
 
   538 			break;
 
   538 		case ETaskFileWrite4KB:
 
   539 		case ETaskFileWrite4KB:
 
   539 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   540 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   540 			test(r==KErrNone);
 
   541 			test_KErrNone(r);
 
   541 			WriteToFile(file,gMinFileSize << 3);	// 512 * 2^3 = 512 * 8 = 4K
 
   542 			WriteToFile(file,gMinFileSize << 3);	// 512 * 2^3 = 512 * 8 = 4K
 
   542 			file.Close();
 
   543 			file.Close();
 
   543 			break;
 
   544 			break;
 
   544 		case ETaskFileWrite64KB:
 
   545 		case ETaskFileWrite64KB:
 
   545 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   546 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   546 			test(r==KErrNone);
 
   547 			test_KErrNone(r);
 
   547 			WriteToFile(file,gMinFileSize<<7);	// 512 * 2^7 = 512 * 128 = 64K
 
   548 			WriteToFile(file,gMinFileSize<<7);	// 512 * 2^7 = 512 * 128 = 64K
 
   548 			file.Close();
 
   549 			file.Close();
 
   549 			break;
 
   550 			break;
 
   550 		case ETaskFileSetSize:
 
   551 		case ETaskFileSetSize:
 
   551 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   552 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   552 			test(r==KErrNone);
 
   553 			test_KErrNone(r);
 
   553 			r=file.SetSize(KFileSize3);
 
   554 			r=file.SetSize(KFileSize3);
 
   554 			file.Close();
 
   555 			file.Close();
 
   555 			break;
 
   556 			break;
 
   556 		case ETaskFileCreateLffs:
 
   557 		case ETaskFileCreateLffs:
 
   557 			r=file.Create(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   558 			r=file.Create(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   558 			test(r==KErrNone);
 
   559 			test_KErrNone(r);
 
   559 			file.Close();
 
   560 			file.Close();
 
   560 			break;
 
   561 			break;
 
   561 		case ETaskNoChange1:
 
   562 		case ETaskNoChange1:
 
   562 			{
 
   563 			{
 
   563 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   564 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
 
   564 			test(r==KErrNone);
 
   565 			test_KErrNone(r);
 
   565 			TTime time;
 
   566 			TTime time;
 
   566 			time.HomeTime();
 
   567 			time.HomeTime();
 
   567 			r=file.SetModified(time);
 
   568 			r=file.SetModified(time);
 
   568 			test(r==KErrNone);
 
   569 			test_KErrNone(r);
 
   569 			file.Close();
 
   570 			file.Close();
 
   570 			break;
 
   571 			break;
 
   571 			}
 
   572 			}
 
   572 		case ETaskNoChange2:
 
   573 		case ETaskNoChange2:
 
   573 			{
 
   574 			{
 
   574 			TEntry e;
 
   575 			TEntry e;
 
   575 			r=fs.Entry(KTestFile1,e);
 
   576 			r=fs.Entry(KTestFile1,e);
 
   576 			test(r==KErrNone);
 
   577 			test_KErrNone(r);
 
   577 			break;
 
   578 			break;
 
   578 			}
 
   579 			}
 
   579 		case ETaskSpin:
 
   580 		case ETaskSpin:
 
   580 			for(;;) {};
 
   581 			for(;;) {};
 
   581 
   582 
   730 //
 
   731 //
 
   731 	{
 
   732 	{
 
   732 	// make default directory
 
   733 	// make default directory
 
   733 	_LIT(defaultDir,"C:\\F32-TST\\");
 
   734 	_LIT(defaultDir,"C:\\F32-TST\\");
 
   734 	TInt r=TheFs.MkDirAll(defaultDir);
 
   735 	TInt r=TheFs.MkDirAll(defaultDir);
 
   735 	test(r==KErrNone||r==KErrAlreadyExists);
 
   736 	test_Value(r, r == KErrNone||r==KErrAlreadyExists);
 
   736 	// create the filler file
 
   737 	// create the filler file
 
   737 	RFile file;
 
   738 	RFile file;
 
   738 	TFileName fileName=_L("C:");
 
   739 	TFileName fileName=_L("C:");
 
   739 	fileName+=KFileFiller;
 
   740 	fileName+=KFileFiller;
 
   740 	r=file.Create(TheFs,fileName,EFileShareAny|EFileWrite);
 
   741 	r=file.Create(TheFs,fileName,EFileShareAny|EFileWrite);
 
   741 	test(r==KErrNone);
 
   742 	test_KErrNone(r);
 
   742 	TInt64 free=FreeDiskSpace(EDriveC);
 
   743 	TInt64 free=FreeDiskSpace(EDriveC);
 
   743 	// use up 16KB
 
   744 	// use up 16KB
 
   744 	FillDisk(file,free-16384,EDriveC);
 
   745 	FillDisk(file,free-16384,EDriveC);
 
   745 
   746 
   746 	// test formatting notifies clients on only specific drive
 
   747 	// test formatting notifies clients on only specific drive
 
   752 	TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2);
 
   753 	TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2);
 
   753 	test(stat1==KRequestPending && stat2==KRequestPending);
 
   754 	test(stat1==KRequestPending && stat2==KRequestPending);
 
   754 	RFormat f;
 
   755 	RFormat f;
 
   755 	TInt count;
 
   756 	TInt count;
 
   756 	r=f.Open(TheFs,RemovableDriveBuf,EQuickFormat,count);
 
   757 	r=f.Open(TheFs,RemovableDriveBuf,EQuickFormat,count);
 
   757 	test(r==KErrNone);
 
   758 	test_KErrNone(r);
 
   758 	while(count)
 
   759 	while(count)
 
   759 		{
 
   760 		{
 
   760 		r=f.Next(count);
 
   761 		r=f.Next(count);
 
   761 		test(r==KErrNone);
 
   762 		test_KErrNone(r);
 
   762 		}
 
   763 		}
 
   763 	f.Close();
 
   764 	f.Close();
 
   764 	User::After(1000000);
 
   765 	User::After(1000000);
 
   765 	User::WaitForRequest(stat2);
 
   766 	User::WaitForRequest(stat2);
 
   766 	test(stat1==KRequestPending && stat2==KErrNone);
 
   767 	test(stat1==KRequestPending && stat2==KErrNone);
 
   770 	// and create the test directory for the removable drive
 
   771 	// and create the test directory for the removable drive
 
   771 	TFileName fName=_L("");
 
   772 	TFileName fName=_L("");
 
   772 	fName+=RemovableDriveBuf;
 
   773 	fName+=RemovableDriveBuf;
 
   773 	fName+=_L("F32-TST\\");
 
   774 	fName+=_L("F32-TST\\");
 
   774 	r=TheFs.MkDirAll(fName);
 
   775 	r=TheFs.MkDirAll(fName);
 
   775 	test(r==KErrNone);
 
   776 	test_KErrNone(r);
 
   776 
   777 
   777 	// test that a media change notifies clients on all drives
 
   778 	// test that a media change notifies clients on all drives
 
   778 	test.Next(_L("media change"));
 
   779 	test.Next(_L("media change"));
 
   779 	freeC=FreeDiskSpace(EDriveC);
 
   780 	freeC=FreeDiskSpace(EDriveC);
 
   780 	freeD=FreeDiskSpace(RemovableDrive);
 
   781 	freeD=FreeDiskSpace(RemovableDrive);
 
   804 
   805 
   805 	// test that scandrive notifies clients on only specific drives
 
   806 	// test that scandrive notifies clients on only specific drives
 
   806 	test.Next(_L("scandrive"));
 
   807 	test.Next(_L("scandrive"));
 
   807 	// first test that scandrive does not find any problems on the removable media
 
   808 	// first test that scandrive does not find any problems on the removable media
 
   808 	r=TheFs.ScanDrive(RemovableDriveBuf);
 
   809 	r=TheFs.ScanDrive(RemovableDriveBuf);
 
   809 	test(r==KErrNone);
 
   810 	test_KErrNone(r);
 
   810 	// now set up disk space notification
 
   811 	// now set up disk space notification
 
   811 	freeC=FreeDiskSpace(EDriveC);
 
   812 	freeC=FreeDiskSpace(EDriveC);
 
   812 	freeD=FreeDiskSpace(RemovableDrive);
 
   813 	freeD=FreeDiskSpace(RemovableDrive);
 
   813 	test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC);
 
   814 	test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC);
 
   814 	test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD);
 
   815 	test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD);
 
   815 	TheFs.NotifyDiskSpace(freeC+8192,EDriveC,stat1);
 
   816 	TheFs.NotifyDiskSpace(freeC+8192,EDriveC,stat1);
 
   816 	TheFs.NotifyDiskSpace(freeD-8192,RemovableDrive,stat2);
 
   817 	TheFs.NotifyDiskSpace(freeD-8192,RemovableDrive,stat2);
 
   817 	test(stat1==KRequestPending && stat2==KRequestPending);
 
   818 	test(stat1==KRequestPending && stat2==KRequestPending);
 
   818 	r=TheFs.ScanDrive(RemovableDriveBuf);
 
   819 	r=TheFs.ScanDrive(RemovableDriveBuf);
 
   819 	test(r==KErrNone);
 
   820 	test_KErrNone(r);
 
   820 	User::After(1000000);
 
   821 	User::After(1000000);
 
   821 	User::WaitForRequest(stat2);
 
   822 	User::WaitForRequest(stat2);
 
   822 	test(stat1==KRequestPending && stat2==KErrNone);
 
   823 	test(stat1==KRequestPending && stat2==KErrNone);
 
   823 	TheFs.NotifyDiskSpaceCancel(stat1);
 
   824 	TheFs.NotifyDiskSpaceCancel(stat1);
 
   824 	test(stat1==KErrCancel);
 
   825 	test(stat1==KErrCancel);
 
   825 
   826 
   826 	file.Close();
 
   827 	file.Close();
 
   827 	r=TheFs.Delete(fileName);
 
   828 	r=TheFs.Delete(fileName);
 
   828 	test(r==KErrNone);
 
   829 	test_KErrNone(r);
 
   829 	if(gSessionPath[0]!=(TText)'C')
 
   830 	if(gSessionPath[0]!=(TText)'C')
 
   830 		{
 
   831 		{
 
   831 		r=TheFs.RmDir(defaultDir);
 
   832 		r=TheFs.RmDir(defaultDir);
 
   832 		test(r==KErrNone||r==KErrInUse);
 
   833 		test_Value(r, r == KErrNone||r==KErrInUse);
 
   833 		}
 
   834 		}
 
   834 
   835 
   835 	}
 
   836 	}
 
   836 
   837 
   837 void TestFunctions()
 
   838 void TestFunctions()
 
   843 	{
 
   844 	{
 
   844 	test.Next(_L("test disk space functions"));
 
   845 	test.Next(_L("test disk space functions"));
 
   845 	// create the filler file
 
   846 	// create the filler file
 
   846 	RFile file;
 
   847 	RFile file;
 
   847 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
   848 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
   848 	test(r==KErrNone);
 
   849 	test_KErrNone(r);
 
   849 	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;
 
   850 	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;
 
   850 	FillDisk(file,newSpace,KDefaultDrive);
 
   851 	FillDisk(file,newSpace,KDefaultDrive);
 
   851 
   852 
   852 	// check file write
 
   853 	// check file write
 
   853 	test.Next(_L("check RFile:Write"));
 
   854 	test.Next(_L("check RFile:Write"));
 
   858 	TInt64 threshold=free-200;
 
   859 	TInt64 threshold=free-200;
 
   859 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   860 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   860 	test(stat1==KRequestPending);
 
   861 	test(stat1==KRequestPending);
 
   861 	RThread thread;
 
   862 	RThread thread;
 
   862 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   863 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   863 	test(r==KErrNone);
 
   864 	test_KErrNone(r);
 
   864 	thread.Resume();
 
   865 	thread.Resume();
 
   865 	User::WaitForRequest(stat1);
 
   866 	User::WaitForRequest(stat1);
 
   866 	test(stat1==KErrNone);
 
   867 	test(stat1==KErrNone);
 
   867 	free=FreeDiskSpace(KDefaultDrive);
 
   868 	free=FreeDiskSpace(KDefaultDrive);
 
   868 	test(free<threshold);
 
   869 	test(free<threshold);
 
   883 		free=FreeDiskSpace(KDefaultDrive);
 
   884 		free=FreeDiskSpace(KDefaultDrive);
 
   884 		threshold=free-100;
 
   885 		threshold=free-100;
 
   885 		TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   886 		TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   886 		test(stat1==KRequestPending);
 
   887 		test(stat1==KRequestPending);
 
   887 		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   888 		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   888 		test(r==KErrNone);
 
   889 		test_KErrNone(r);
 
   889 		TRequestStatus deathStat;
 
   890 		TRequestStatus deathStat;
 
   890 		thread.Logon( deathStat );
 
   891 		thread.Logon( deathStat );
 
   891 		thread.Resume();
 
   892 		thread.Resume();
 
   892 		User::WaitForRequest(stat1);
 
   893 		User::WaitForRequest(stat1);
 
   893 		test(stat1==KErrNone);
 
   894 		test(stat1==KErrNone);
 
   909 	free=FreeDiskSpace(KDefaultDrive);
 
   910 	free=FreeDiskSpace(KDefaultDrive);
 
   910 	threshold=free+100;
 
   911 	threshold=free+100;
 
   911 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   912 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   912 	test(stat1==KRequestPending);
 
   913 	test(stat1==KRequestPending);
 
   913 	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   914 	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   914 	test(r==KErrNone);
 
   915 	test_KErrNone(r);
 
   915 	thread.Logon( deathStat );
 
   916 	thread.Logon( deathStat );
 
   916 	thread.Resume();
 
   917 	thread.Resume();
 
   917 
   918 
   918 	User::After(1000000);
 
   919 	User::After(1000000);
 
   919 
   920 
   942 	free=FreeDiskSpace(KDefaultDrive);
 
   943 	free=FreeDiskSpace(KDefaultDrive);
 
   943 	threshold=free+300;
 
   944 	threshold=free+300;
 
   944 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   945 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   945 	test(stat1==KRequestPending);
 
   946 	test(stat1==KRequestPending);
 
   946 	r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   947 	r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   947 	test(r==KErrNone);
 
   948 	test_KErrNone(r);
 
   948 	thread.Logon( deathStat );
 
   949 	thread.Logon( deathStat );
 
   949 	thread.Resume();
 
   950 	thread.Resume();
 
   950 	User::WaitForRequest(stat1);
 
   951 	User::WaitForRequest(stat1);
 
   951 	test(stat1==KErrNone);
 
   952 	test(stat1==KErrNone);
 
   952 	free=FreeDiskSpace(KDefaultDrive);
 
   953 	free=FreeDiskSpace(KDefaultDrive);
 
   978 
   979 
   979 	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   980 	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
   980 	    test(stat1==KRequestPending);
 
   981 	    test(stat1==KRequestPending);
 
   981 
   982 
   982 	    r=thread.Create(_L("thread5"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   983 	    r=thread.Create(_L("thread5"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
   983 	    test(r==KErrNone);
 
   984 	    test_KErrNone(r);
 
   984 	    thread.Logon( deathStat );
 
   985 	    thread.Logon( deathStat );
 
   985 	    thread.Resume();
 
   986 	    thread.Resume();
 
   986 
   987 
   987 	    User::After(1000000);
 
   988 	    User::After(1000000);
 
   988 	    test(stat1==KRequestPending);
 
   989 	    test(stat1==KRequestPending);
 
  1002 	    free=FreeDiskSpace(KDefaultDrive);
 
  1003 	    free=FreeDiskSpace(KDefaultDrive);
 
  1003 	    threshold=free+200;
 
  1004 	    threshold=free+200;
 
  1004 	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
  1005 	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 
  1005 	    test(stat1==KRequestPending);
 
  1006 	    test(stat1==KRequestPending);
 
  1006 	    r=thread.Create(_L("thread6"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1007 	    r=thread.Create(_L("thread6"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1007 	    test(r==KErrNone);
 
  1008 	    test_KErrNone(r);
 
  1008 	    thread.Logon( deathStat );
 
  1009 	    thread.Logon( deathStat );
 
  1009 	    thread.Resume();
 
  1010 	    thread.Resume();
 
  1010 	    User::WaitForRequest(stat1);
 
  1011 	    User::WaitForRequest(stat1);
 
  1011 	    //User::After(1000000);
 
  1012 	    //User::After(1000000);
 
  1012 	    test(stat1==KErrNone);
 
  1013 	    test(stat1==KErrNone);
 
  1031 		_LIT(someFile,"X:\\abcdef");
 
  1032 		_LIT(someFile,"X:\\abcdef");
 
  1032 #else
 
  1033 #else
 
  1033 		TBuf<10> someFile=_L("?:\\abcdef");
 
  1034 		TBuf<10> someFile=_L("?:\\abcdef");
 
  1034 		TChar c;
 
  1035 		TChar c;
 
  1035 		TInt r=RFs::DriveToChar(RemovableDrive,c);
 
  1036 		TInt r=RFs::DriveToChar(RemovableDrive,c);
 
  1036 		test(r==KErrNone);
 
  1037 		test_KErrNone(r);
 
  1037 		someFile[0]=(TText)c;
 
  1038 		someFile[0]=(TText)c;
 
  1038 #endif
 
  1039 #endif
 
  1039 		_LIT(someDir,"C:\\1234\\");
 
  1040 		_LIT(someDir,"C:\\1234\\");
 
  1040 
  1041 
  1041 		r=f2.Create(TheFs,someFile,EFileShareAny|EFileWrite);
 
  1042 		r=f2.Create(TheFs,someFile,EFileShareAny|EFileWrite);
 
  1042 		test(r==KErrNone);
 
  1043 		test_KErrNone(r);
 
  1043 		r=TheFs.MkDir(someDir);
 
  1044 		r=TheFs.MkDir(someDir);
 
  1044 		test(r==KErrNone);
 
  1045 		test_KErrNone(r);
 
  1045 		TRequestStatus stat2;
 
  1046 		TRequestStatus stat2;
 
  1046 		TInt64 freeC=FreeDiskSpace(EDriveC);
 
  1047 		TInt64 freeC=FreeDiskSpace(EDriveC);
 
  1047 		TInt64 freeD=FreeDiskSpace(RemovableDrive);
 
  1048 		TInt64 freeD=FreeDiskSpace(RemovableDrive);
 
  1048 		TheFs.NotifyDiskSpace(freeC-4097,EDriveC,stat1);
 
  1049 		TheFs.NotifyDiskSpace(freeC-4097,EDriveC,stat1);
 
  1049 		TheFs.NotifyDiskSpace(freeD-4097,RemovableDrive,stat2);
 
  1050 		TheFs.NotifyDiskSpace(freeD-4097,RemovableDrive,stat2);
 
  1050 		test(stat1==KRequestPending && stat2==KRequestPending);
 
  1051 		test(stat1==KRequestPending && stat2==KRequestPending);
 
  1051 		// before fix this would result in iTheDrive not being updated in next subsession call
 
  1052 		// before fix this would result in iTheDrive not being updated in next subsession call
 
  1052 		// therefore this could would not result in a disk space notification
 
  1053 		// therefore this could would not result in a disk space notification
 
  1053 		r=f2.SetSize(8192);
 
  1054 		r=f2.SetSize(8192);
 
  1054 		test(r==KErrNone);
 
  1055 		test_KErrNone(r);
 
  1055 		User::After(1000000);
 
  1056 		User::After(1000000);
 
  1056 		User::WaitForRequest(stat2);
 
  1057 		User::WaitForRequest(stat2);
 
  1057 
  1058 
  1058 		if (stat2!=KErrNone)
 
  1059 		if (stat2!=KErrNone)
 
  1059 			test.Printf(_L("stat2=%d\n"),stat2.Int());
 
  1060 			test.Printf(_L("stat2=%d\n"),stat2.Int());
 
  1064 
  1065 
  1065 		f2.Close();
 
  1066 		f2.Close();
 
  1066 		TheFs.NotifyDiskSpaceCancel();
 
  1067 		TheFs.NotifyDiskSpaceCancel();
 
  1067 		test(stat1==KErrCancel);
 
  1068 		test(stat1==KErrCancel);
 
  1068 		r=TheFs.Delete(someFile);
 
  1069 		r=TheFs.Delete(someFile);
 
  1069 		test(r==KErrNone);
 
  1070 		test_KErrNone(r);
 
  1070 		r=TheFs.RmDir(someDir);
 
  1071 		r=TheFs.RmDir(someDir);
 
  1071 		test(r==KErrNone);
 
  1072 		test_KErrNone(r);
 
  1072 		}
 
  1073 		}
 
  1073 
  1074 
  1074 	file.Close();
 
  1075 	file.Close();
 
  1075 	r=TheFs.Delete(KFileFiller);
 
  1076 	r=TheFs.Delete(KFileFiller);
 
  1076 	test(r==KErrNone);
 
  1077 	test_KErrNone(r);
 
  1077 	}
 
  1078 	}
 
  1078 
  1079 
  1079 
  1080 
  1080 
  1081 
  1081 void TestLffsFunctions()
 
  1082 void TestLffsFunctions()
 
  1087 	{
 
  1088 	{
 
  1088 	test.Next(_L("test LFFS disk space functions"));
 
  1089 	test.Next(_L("test LFFS disk space functions"));
 
  1089 	// create the filler file
 
  1090 	// create the filler file
 
  1090 	RFile file;
 
  1091 	RFile file;
 
  1091 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1092 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1092 	test(r==KErrNone);
 
  1093 	test_KErrNone(r);
 
  1093 	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;
 
  1094 	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;
 
  1094 	FillDisk(file,newSpace,KDefaultDrive);
 
  1095 	FillDisk(file,newSpace,KDefaultDrive);
 
  1095 
  1096 
  1096 
  1097 
  1097 	// check file create
 
  1098 	// check file create
 
  1106 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1107 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1107 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1108 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1108 	test(stat1==KRequestPending && stat2==KRequestPending);
 
  1109 	test(stat1==KRequestPending && stat2==KRequestPending);
 
  1109 	RThread thread;
 
  1110 	RThread thread;
 
  1110 	r=thread.Create(_L("thread7"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1111 	r=thread.Create(_L("thread7"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1111 	test(r==KErrNone);
 
  1112 	test_KErrNone(r);
 
  1112 	TRequestStatus deathStat;
 
  1113 	TRequestStatus deathStat;
 
  1113 	thread.Logon( deathStat );
 
  1114 	thread.Logon( deathStat );
 
  1114 	thread.Resume();
 
  1115 	thread.Resume();
 
  1115 	User::WaitForRequest(stat1);
 
  1116 	User::WaitForRequest(stat1);
 
  1116 	test(stat1==KErrNone);
 
  1117 	test(stat1==KErrNone);
 
  1141 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1142 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1142 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1143 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1143 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1144 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1144 	test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending);
 
  1145 	test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending);
 
  1145 	r=thread.Create(_L("thread8"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1146 	r=thread.Create(_L("thread8"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1146 	test(r==KErrNone);
 
  1147 	test_KErrNone(r);
 
  1147 	thread.Logon( deathStat );
 
  1148 	thread.Logon( deathStat );
 
  1148 	thread.SetPriority( EPriorityLess );
 
  1149 	thread.SetPriority( EPriorityLess );
 
  1149 	thread.Resume();	// start spinning, blocks background thread
 
  1150 	thread.Resume();	// start spinning, blocks background thread
 
  1150 	// request background thread to notify a daft value
 
  1151 	// request background thread to notify a daft value
 
  1151     TPckgBuf<TInt64> cBuf;
 
  1152     TPckgBuf<TInt64> cBuf;
 
  1156 	#define ECioBackgroundNotifyDiskSize 10016
 
  1157 	#define ECioBackgroundNotifyDiskSize 10016
 
  1157 	r = TheFs.ControlIo(GetDriveLFFS(), ECioBackgroundNotifyDiskSize, cBuf);
 
  1158 	r = TheFs.ControlIo(GetDriveLFFS(), ECioBackgroundNotifyDiskSize, cBuf);
 
  1158 	test( KErrNone==r );
 
  1159 	test( KErrNone==r );
 
  1159 	// create a  file to force some roll-forward
 
  1160 	// create a  file to force some roll-forward
 
  1160 	r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
  1161 	r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
  1161 	test(r==KErrNone);
 
  1162 	test_KErrNone(r);
 
  1162 	User::WaitForRequest(stat1);
 
  1163 	User::WaitForRequest(stat1);
 
  1163 	test(stat1==KErrNone);
 
  1164 	test(stat1==KErrNone);
 
  1164 	test(stat2==KRequestPending);
 
  1165 	test(stat2==KRequestPending);
 
  1165 	test(stat3==KRequestPending);
 
  1166 	test(stat3==KRequestPending);
 
  1166 	// kill the spinner thread to allow the background thread to execute
 
  1167 	// kill the spinner thread to allow the background thread to execute
 
  1191 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1192 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1192 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1193 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1193 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1194 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1194 	test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending);
 
  1195 	test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending);
 
  1195 	r=thread.Create(_L("thread9"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1196 	r=thread.Create(_L("thread9"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1196 	test(r==KErrNone);
 
  1197 	test_KErrNone(r);
 
  1197 	thread.Logon( deathStat );
 
  1198 	thread.Logon( deathStat );
 
  1198 	thread.SetPriority( EPriorityLess );
 
  1199 	thread.SetPriority( EPriorityLess );
 
  1199 	thread.Resume();	// start spinning, blocks background thread
 
  1200 	thread.Resume();	// start spinning, blocks background thread
 
  1200 	// create a  file to force some roll-forward
 
  1201 	// create a  file to force some roll-forward
 
  1201 	r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
  1202 	r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
 
  1202 	test(r==KErrNone);
 
  1203 	test_KErrNone(r);
 
  1203 	User::WaitForRequest(stat1);
 
  1204 	User::WaitForRequest(stat1);
 
  1204 	test(stat1==KErrNone);
 
  1205 	test(stat1==KErrNone);
 
  1205 	test(stat2==KRequestPending);
 
  1206 	test(stat2==KRequestPending);
 
  1206 	test(stat3==KRequestPending);
 
  1207 	test(stat3==KRequestPending);
 
  1207 	// kill the spinner thread to allow the background thread to execute
 
  1208 	// kill the spinner thread to allow the background thread to execute
 
  1222 	TheFs.Delete( KTestFile1 );
 
  1223 	TheFs.Delete( KTestFile1 );
 
  1223 
  1224 
  1224 
  1225 
  1225 	file.Close();
 
  1226 	file.Close();
 
  1226 	r=TheFs.Delete(KFileFiller);
 
  1227 	r=TheFs.Delete(KFileFiller);
 
  1227 	test(r==KErrNone);
 
  1228 	test_KErrNone(r);
 
  1228 	}
 
  1229 	}
 
  1229 
  1230 
  1230 
  1231 
  1231 void TestMultiple()
 
  1232 void TestMultiple()
 
  1232 //
 
  1233 //
 
  1234 //
 
  1235 //
 
  1235 	{
 
  1236 	{
 
  1236 	// create the filler file
 
  1237 	// create the filler file
 
  1237 	RFile file;
 
  1238 	RFile file;
 
  1238 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1239 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1239 	test(r==KErrNone);
 
  1240 	test_KErrNone(r);
 
  1240 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 
  1241 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 
  1241 	TInt64 freeSpaceLeft = gMinFileSize << 4;	// 512 * 2^4 = 512 * 16 = 8K
 
  1242 	TInt64 freeSpaceLeft = gMinFileSize << 4;	// 512 * 2^4 = 512 * 16 = 8K
 
  1242 	FillDisk(file,free-freeSpaceLeft,KDefaultDrive);
 
  1243 	FillDisk(file,free-freeSpaceLeft,KDefaultDrive);
 
  1243 	TInt size;
 
  1244 	TInt size;
 
  1244 	r=file.Size(size);
 
  1245 	r=file.Size(size);
 
  1245 	test(r==KErrNone);
 
  1246 	test_KErrNone(r);
 
  1246 	test(size>1024);
 
  1247 	test(size>1024);
 
  1247 	test.Printf(_L("filler file size=0x%x\n"),size);
 
  1248 	test.Printf(_L("filler file size=0x%x\n"),size);
 
  1248 
  1249 
  1249 	// test multiple requests
 
  1250 	// test multiple requests
 
  1250 	test.Next(_L("test multiple requests"));
 
  1251 	test.Next(_L("test multiple requests"));
 
  1263 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1264 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1264 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1265 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1265 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1266 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1266 	RThread thread;
 
  1267 	RThread thread;
 
  1267 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1268 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1268 	test(r==KErrNone);
 
  1269 	test_KErrNone(r);
 
  1269 	TRequestStatus deathStat;
 
  1270 	TRequestStatus deathStat;
 
  1270 	thread.Logon( deathStat );
 
  1271 	thread.Logon( deathStat );
 
  1271 	thread.Resume();
 
  1272 	thread.Resume();
 
  1272 	User::After(1000000);
 
  1273 	User::After(1000000);
 
  1273 	User::WaitForRequest(stat1);
 
  1274 	User::WaitForRequest(stat1);
 
  1300 		TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1301 		TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1301 		TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1302 		TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1302 		TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1303 		TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1303 		test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1304 		test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1304 		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1305 		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1305 		test(r==KErrNone);
 
  1306 		test_KErrNone(r);
 
  1306 		thread.Logon( deathStat );
 
  1307 		thread.Logon( deathStat );
 
  1307 		thread.Resume();
 
  1308 		thread.Resume();
 
  1308 		User::After(10000);
 
  1309 		User::After(10000);
 
  1309 		User::WaitForRequest(stat3);
 
  1310 		User::WaitForRequest(stat3);
 
  1310 		test(stat3==KErrNone && stat1==KRequestPending && stat2==KRequestPending);
 
  1311 		test(stat3==KErrNone && stat1==KRequestPending && stat2==KRequestPending);
 
  1337 
  1338 
  1338 	// test multiple sessions all notified on disk space change
 
  1339 	// test multiple sessions all notified on disk space change
 
  1339 	test.Next(_L("test multiple sessions on same drive"));
 
  1340 	test.Next(_L("test multiple sessions on same drive"));
 
  1340 	RFs ses2,ses3;
 
  1341 	RFs ses2,ses3;
 
  1341 	r=ses2.Connect();
 
  1342 	r=ses2.Connect();
 
  1342 	test(r==KErrNone);
 
  1343 	test_KErrNone(r);
 
  1343 	r=ses3.Connect();
 
  1344 	r=ses3.Connect();
 
  1344 	test(r==KErrNone);
 
  1345 	test_KErrNone(r);
 
  1345 	r=ses2.SetSessionPath(gSessionPath);
 
  1346 	r=ses2.SetSessionPath(gSessionPath);
 
  1346 	test(r==KErrNone);
 
  1347 	test_KErrNone(r);
 
  1347 	r=ses3.SetSessionPath(gSessionPath);
 
  1348 	r=ses3.SetSessionPath(gSessionPath);
 
  1348 	test(r==KErrNone);
 
  1349 	test_KErrNone(r);
 
  1349 	task=ETaskFileReplace;
 
  1350 	task=ETaskFileReplace;
 
  1350 	InitialiseForThread(task);
 
  1351 	InitialiseForThread(task);
 
  1351 	free=FreeDiskSpace(KDefaultDrive);
 
  1352 	free=FreeDiskSpace(KDefaultDrive);
 
  1352 	test.Printf(_L("free space on default drive = 0x%x\n"),free);
 
  1353 	test.Printf(_L("free space on default drive = 0x%x\n"),free);
 
  1353 	threshold1=free+gMinFileSize;			// 512
 
  1354 	threshold1=free+gMinFileSize;			// 512
 
  1356 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1357 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1357 	ses2.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1358 	ses2.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1358 	ses3.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1359 	ses3.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1359 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1360 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1360 	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1361 	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1361 	test(r==KErrNone);
 
  1362 	test_KErrNone(r);
 
  1362 	thread.Logon( deathStat );
 
  1363 	thread.Logon( deathStat );
 
  1363 	thread.Resume();
 
  1364 	thread.Resume();
 
  1364 	User::After(1000000);
 
  1365 	User::After(1000000);
 
  1365 	User::WaitForRequest(stat1);
 
  1366 	User::WaitForRequest(stat1);
 
  1366 	User::WaitForRequest(stat2);
 
  1367 	User::WaitForRequest(stat2);
 
  1388 
  1389 
  1389 	if( !LffsDrive )
 
  1390 	if( !LffsDrive )
 
  1390 		{
 
  1391 		{
 
  1391 		TInt sessionDrive;
 
  1392 		TInt sessionDrive;
 
  1392 		r=RFs::CharToDrive(gSessionPath[0],sessionDrive);
 
  1393 		r=RFs::CharToDrive(gSessionPath[0],sessionDrive);
 
  1393 		test(r==KErrNone);
 
  1394 		test_KErrNone(r);
 
  1394 		if(sessionDrive!=RemovableDrive)
 
  1395 		if(sessionDrive!=RemovableDrive)
 
  1395 			{
 
  1396 			{
 
  1396 			// first create a file on the removable drive
 
  1397 			// first create a file on the removable drive
 
  1397 			RFile file2;
 
  1398 			RFile file2;
 
  1398 			TFileName file2name=RemovableDriveBuf;
 
  1399 			TFileName file2name=RemovableDriveBuf;
 
  1399 			file2name+=_L("F32-TST\\testfile1");
 
  1400 			file2name+=_L("F32-TST\\testfile1");
 
  1400 			TheFs.Delete(file2name);
 
  1401 			TheFs.Delete(file2name);
 
  1401 			r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite);
 
  1402 			r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite);
 
  1402 			test(r==KErrNone);
 
  1403 			test_KErrNone(r);
 
  1403 			r=file2.SetSize(KFileSize3);
 
  1404 			r=file2.SetSize(KFileSize3);
 
  1404 			test(r==KErrNone);
 
  1405 			test_KErrNone(r);
 
  1405 			// test multiple sessions not notified on disk space change on wrong drive
 
  1406 			// test multiple sessions not notified on disk space change on wrong drive
 
  1406 			test.Next(_L("test multiple sessions on different drives"));
 
  1407 			test.Next(_L("test multiple sessions on different drives"));
 
  1407 			task=ETaskFileReplace;
 
  1408 			task=ETaskFileReplace;
 
  1408 			InitialiseForThread(task);
 
  1409 			InitialiseForThread(task);
 
  1409 			TInt64 freeDef=FreeDiskSpace(KDefaultDrive);
 
  1410 			TInt64 freeDef=FreeDiskSpace(KDefaultDrive);
 
  1412 			threshold2=freeRem + (gMinFileSize << 1);	// 1024;
 
  1413 			threshold2=freeRem + (gMinFileSize << 1);	// 1024;
 
  1413 			TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1414 			TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1414 			ses2.NotifyDiskSpace(threshold2,RemovableDrive,stat2);
 
  1415 			ses2.NotifyDiskSpace(threshold2,RemovableDrive,stat2);
 
  1415 			test(stat1==KRequestPending&&stat2==KRequestPending);
 
  1416 			test(stat1==KRequestPending&&stat2==KRequestPending);
 
  1416 			r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1417 			r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1417 			test(r==KErrNone);
 
  1418 			test_KErrNone(r);
 
  1418 			thread.Logon( deathStat );
 
  1419 			thread.Logon( deathStat );
 
  1419 			thread.Resume();
 
  1420 			thread.Resume();
 
  1420 			User::After(1000000);
 
  1421 			User::After(1000000);
 
  1421 			User::WaitForRequest(stat1);
 
  1422 			User::WaitForRequest(stat1);
 
  1422 			test(stat1==KErrNone && stat2==KRequestPending);
 
  1423 			test(stat1==KErrNone && stat2==KRequestPending);
 
  1429 			test(stat2==KRequestPending);
 
  1430 			test(stat2==KRequestPending);
 
  1430 			ses2.NotifyDiskSpaceCancel(stat2);
 
  1431 			ses2.NotifyDiskSpaceCancel(stat2);
 
  1431 			test(stat2==KErrCancel);
 
  1432 			test(stat2==KErrCancel);
 
  1432 			file2.Close();
 
  1433 			file2.Close();
 
  1433 			r=TheFs.Delete(file2name);
 
  1434 			r=TheFs.Delete(file2name);
 
  1434 			test(r==KErrNone);
 
  1435 			test_KErrNone(r);
 
  1435 			}
 
  1436 			}
 
  1436 		}
 
  1437 		}
 
  1437 
  1438 
  1438 	ses2.Close();
 
  1439 	ses2.Close();
 
  1439 	ses3.Close();
 
  1440 	ses3.Close();
 
  1440 
  1441 
  1441 
  1442 
  1442 	file.Close();
 
  1443 	file.Close();
 
  1443 	r=TheFs.Delete(KFileFiller);
 
  1444 	r=TheFs.Delete(KFileFiller);
 
  1444 	test(r==KErrNone);
 
  1445 	test_KErrNone(r);
 
  1445 
  1446 
  1446 	}
 
  1447 	}
 
  1447 
  1448 
  1448 
  1449 
  1449 void TestLffsMultiple()
 
  1450 void TestLffsMultiple()
 
  1452 //
 
  1453 //
 
  1453 	{
 
  1454 	{
 
  1454 	// create the filler file
 
  1455 	// create the filler file
 
  1455 	RFile file;
 
  1456 	RFile file;
 
  1456 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1457 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1457 	test(r==KErrNone);
 
  1458 	test_KErrNone(r);
 
  1458 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 
  1459 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 
  1459 	FillDisk(file,free-8192,KDefaultDrive);
 
  1460 	FillDisk(file,free-8192,KDefaultDrive);
 
  1460 	TInt size;
 
  1461 	TInt size;
 
  1461 	r=file.Size(size);
 
  1462 	r=file.Size(size);
 
  1462 	test(r==KErrNone);
 
  1463 	test_KErrNone(r);
 
  1463 	test.Printf(_L("filler file size=0x%x\n"),size);
 
  1464 	test.Printf(_L("filler file size=0x%x\n"),size);
 
  1464 
  1465 
  1465 
  1466 
  1466 	// test multiple requests again
 
  1467 	// test multiple requests again
 
  1467 	test.Next(_L("test multiple requests on LFFS") );
 
  1468 	test.Next(_L("test multiple requests on LFFS") );
 
  1478 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1479 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1479 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1480 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 
  1480 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1481 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1481 	RThread thread;
 
  1482 	RThread thread;
 
  1482 	r=thread.Create(_L("thread10"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1483 	r=thread.Create(_L("thread10"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1483 	test(r==KErrNone);
 
  1484 	test_KErrNone(r);
 
  1484 	TRequestStatus deathStat;
 
  1485 	TRequestStatus deathStat;
 
  1485 	thread.Logon( deathStat );
 
  1486 	thread.Logon( deathStat );
 
  1486 //	test.Printf(_L("Resuming other thread"));
 
  1487 //	test.Printf(_L("Resuming other thread"));
 
  1487 	thread.Resume();
 
  1488 	thread.Resume();
 
  1488 	User::After(10000);
 
  1489 	User::After(10000);
 
  1509 
  1510 
  1510 
  1511 
  1511 
  1512 
  1512 	TInt sessionDrive;
 
  1513 	TInt sessionDrive;
 
  1513 	r=RFs::CharToDrive(gSessionPath[0],sessionDrive);
 
  1514 	r=RFs::CharToDrive(gSessionPath[0],sessionDrive);
 
  1514 	test(r==KErrNone);
 
  1515 	test_KErrNone(r);
 
  1515 	if(sessionDrive!=EDriveC)
 
  1516 	if(sessionDrive!=EDriveC)
 
  1516 		{
 
  1517 		{
 
  1517 		// test multiple sessions not notified on disk space change on wrong drive
 
  1518 		// test multiple sessions not notified on disk space change on wrong drive
 
  1518 		test.Next(_L("test multiple sessions on different drives"));
 
  1519 		test.Next(_L("test multiple sessions on different drives"));
 
  1519 
  1520 
  1520 		RFs ses2,ses3;
 
  1521 		RFs ses2,ses3;
 
  1521 		r=ses2.Connect();
 
  1522 		r=ses2.Connect();
 
  1522 		test(r==KErrNone);
 
  1523 		test_KErrNone(r);
 
  1523 		r=ses3.Connect();
 
  1524 		r=ses3.Connect();
 
  1524 		test(r==KErrNone);
 
  1525 		test_KErrNone(r);
 
  1525 		r=ses2.SetSessionPath(gSessionPath);
 
  1526 		r=ses2.SetSessionPath(gSessionPath);
 
  1526 		test(r==KErrNone);
 
  1527 		test_KErrNone(r);
 
  1527 		r=ses3.SetSessionPath(gSessionPath);
 
  1528 		r=ses3.SetSessionPath(gSessionPath);
 
  1528 		test(r==KErrNone);
 
  1529 		test_KErrNone(r);
 
  1529 
  1530 
  1530 		// first create a file on the C:\ drive
 
  1531 		// first create a file on the C:\ drive
 
  1531 		RFile file2;
 
  1532 		RFile file2;
 
  1532 		TFileName file2name=_L("C:\\");
 
  1533 		TFileName file2name=_L("C:\\");
 
  1533 		file2name+=_L("F32-TST\\");
 
  1534 		file2name+=_L("F32-TST\\");
 
  1534 		r=TheFs.MkDir(file2name);
 
  1535 		r=TheFs.MkDir(file2name);
 
  1535 		test( KErrNone==r || KErrAlreadyExists==r );
 
  1536 		test( KErrNone==r || KErrAlreadyExists==r );
 
  1536 		file2name+=_L("testfile1");
 
  1537 		file2name+=_L("testfile1");
 
  1537 		TheFs.Delete(file2name);
 
  1538 		TheFs.Delete(file2name);
 
  1538 		r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite);
 
  1539 		r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite);
 
  1539 		test(r==KErrNone);
 
  1540 		test_KErrNone(r);
 
  1540 		WriteToFile( file2, KFileSize3 );
 
  1541 		WriteToFile( file2, KFileSize3 );
 
  1541 
  1542 
  1542 		task=ETaskFileReplace;
 
  1543 		task=ETaskFileReplace;
 
  1543 		InitialiseForThread(task);
 
  1544 		InitialiseForThread(task);
 
  1544 		TInt64 freeLffs=FreeDiskSpace(KDefaultDrive);
 
  1545 		TInt64 freeLffs=FreeDiskSpace(KDefaultDrive);
 
  1547 		threshold2=freeD+1024;
 
  1548 		threshold2=freeD+1024;
 
  1548 		TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1549 		TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1549 		ses2.NotifyDiskSpace(threshold2,EDriveC,stat2);
 
  1550 		ses2.NotifyDiskSpace(threshold2,EDriveC,stat2);
 
  1550 		test(stat1==KRequestPending&&stat2==KRequestPending);
 
  1551 		test(stat1==KRequestPending&&stat2==KRequestPending);
 
  1551 		r=thread.Create(_L("thread11"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1552 		r=thread.Create(_L("thread11"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1552 		test(r==KErrNone);
 
  1553 		test_KErrNone(r);
 
  1553 		thread.Logon( deathStat );
 
  1554 		thread.Logon( deathStat );
 
  1554 		thread.Resume();
 
  1555 		thread.Resume();
 
  1555 		User::After(1000000);
 
  1556 		User::After(1000000);
 
  1556 		User::WaitForRequest(stat1);
 
  1557 		User::WaitForRequest(stat1);
 
  1557 		test(stat1==KErrNone && stat2==KRequestPending);
 
  1558 		test(stat1==KErrNone && stat2==KRequestPending);
 
  1565 		ses2.NotifyDiskSpaceCancel(stat2);
 
  1566 		ses2.NotifyDiskSpaceCancel(stat2);
 
  1566 		User::WaitForRequest( stat2 );
 
  1567 		User::WaitForRequest( stat2 );
 
  1567 		test(stat2==KErrCancel);
 
  1568 		test(stat2==KErrCancel);
 
  1568 		file2.Close();
 
  1569 		file2.Close();
 
  1569 		r=TheFs.Delete(file2name);
 
  1570 		r=TheFs.Delete(file2name);
 
  1570 		test(r==KErrNone);
 
  1571 		test_KErrNone(r);
 
  1571 		ses2.Close();
 
  1572 		ses2.Close();
 
  1572 		ses3.Close();
 
  1573 		ses3.Close();
 
  1573 		}
 
  1574 		}
 
  1574 
  1575 
  1575 
  1576 
  1576 
  1577 
  1577 	file.Close();
 
  1578 	file.Close();
 
  1578 	r=TheFs.Delete(KFileFiller);
 
  1579 	r=TheFs.Delete(KFileFiller);
 
  1579 	test(r==KErrNone);
 
  1580 	test_KErrNone(r);
 
  1580 
  1581 
  1581 	}
 
  1582 	}
 
  1582 
  1583 
  1583 
  1584 
  1584 void TestChangeNotification()
 
  1585 void TestChangeNotification()
 
  1587 //
 
  1588 //
 
  1588 	{
 
  1589 	{
 
  1589 	// create a filler file
 
  1590 	// create a filler file
 
  1590 	RFile file;
 
  1591 	RFile file;
 
  1591 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1592 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 
  1592 	test(r==KErrNone);
 
  1593 	test_KErrNone(r);
 
  1593 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 
  1594 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 
  1594 	// use 8KB in filler file
 
  1595 	// use 8KB in filler file
 
  1595 	FillDisk(file,free-8192,KDefaultDrive);
 
  1596 	FillDisk(file,free-8192,KDefaultDrive);
 
  1596 
  1597 
  1597 	// test change notification when no disk space change
 
  1598 	// test change notification when no disk space change
 
  1606 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1607 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 
  1607 	TheFs.NotifyChange(ENotifyAll,stat3);
 
  1608 	TheFs.NotifyChange(ENotifyAll,stat3);
 
  1608 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1609 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1609 	RThread thread;
 
  1610 	RThread thread;
 
  1610 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1611 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1611 	test(r==KErrNone);
 
  1612 	test_KErrNone(r);
 
  1612 	TRequestStatus deathStat;
 
  1613 	TRequestStatus deathStat;
 
  1613 	thread.Logon( deathStat );
 
  1614 	thread.Logon( deathStat );
 
  1614 	thread.Resume();
 
  1615 	thread.Resume();
 
  1615 	User::After(1000000);
 
  1616 	User::After(1000000);
 
  1616 	User::WaitForRequest(stat3);
 
  1617 	User::WaitForRequest(stat3);
 
  1633 	// do an operation that will cause the change notification
 
  1634 	// do an operation that will cause the change notification
 
  1634 	// and disk change notification to be signalled
 
  1635 	// and disk change notification to be signalled
 
  1635 	test.Next(_L(" test change notification and disk space notification"));
 
  1636 	test.Next(_L(" test change notification and disk space notification"));
 
  1636 	RFs session2,session3;
 
  1637 	RFs session2,session3;
 
  1637 	r=session2.Connect();
 
  1638 	r=session2.Connect();
 
  1638 	test(r==KErrNone);
 
  1639 	test_KErrNone(r);
 
  1639 	r=session3.Connect();
 
  1640 	r=session3.Connect();
 
  1640 	test(r==KErrNone);
 
  1641 	test_KErrNone(r);
 
  1641 	r=session2.SetSessionPath(gSessionPath);
 
  1642 	r=session2.SetSessionPath(gSessionPath);
 
  1642 	test(r==KErrNone);
 
  1643 	test_KErrNone(r);
 
  1643 	r=session3.SetSessionPath(gSessionPath);
 
  1644 	r=session3.SetSessionPath(gSessionPath);
 
  1644 	test(r==KErrNone);
 
  1645 	test_KErrNone(r);
 
  1645 	task=ETaskFileWrite;
 
  1646 	task=ETaskFileWrite;
 
  1646 	InitialiseForThread(task);
 
  1647 	InitialiseForThread(task);
 
  1647 	free=FreeDiskSpace(KDefaultDrive);
 
  1648 	free=FreeDiskSpace(KDefaultDrive);
 
  1648 	threshold1=free-400;
 
  1649 	threshold1=free-400;
 
  1649 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1650 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 
  1650 	session2.NotifyChange(ENotifyAll,stat2);
 
  1651 	session2.NotifyChange(ENotifyAll,stat2);
 
  1651 	session3.NotifyChange(ENotifyAll,stat3,KTestFile1);
 
  1652 	session3.NotifyChange(ENotifyAll,stat3,KTestFile1);
 
  1652 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1653 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 
  1653 	r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1654 	r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
 
  1654 	test(r==KErrNone);
 
  1655 	test_KErrNone(r);
 
  1655 	thread.Logon( deathStat );
 
  1656 	thread.Logon( deathStat );
 
  1656 	thread.Resume();
 
  1657 	thread.Resume();
 
  1657 	User::After(1000000);
 
  1658 	User::After(1000000);
 
  1658 	User::WaitForRequest(stat1);
 
  1659 	User::WaitForRequest(stat1);
 
  1659 	User::WaitForRequest(stat2);
 
  1660 	User::WaitForRequest(stat2);
 
  1690 	session2.Close();
 
  1691 	session2.Close();
 
  1691 	session3.Close();
 
  1692 	session3.Close();
 
  1692 
  1693 
  1693 	file.Close();
 
  1694 	file.Close();
 
  1694 	r=TheFs.Delete(KFileFiller);
 
  1695 	r=TheFs.Delete(KFileFiller);
 
  1695 	test(r==KErrNone);
 
  1696 	test_KErrNone(r);
 
  1696 
  1697 
  1697 	}
 
  1698 	}
 
  1698 
  1699 
  1699 //-------------------------------------------------------------------------------------------------
 
  1700 //-------------------------------------------------------------------------------------------------
 
  1700 // Test the fix for:
 
  1701 // Test the fix for:
 
  1706 
  1707 
  1707 _LIT(KPreModifierPluginFileName,"premodifier_plugin");
 
  1708 _LIT(KPreModifierPluginFileName,"premodifier_plugin");
 
  1708 _LIT(KPreModifierPluginName,"PreModifierPlugin");
 
  1709 _LIT(KPreModifierPluginName,"PreModifierPlugin");
 
  1709 const TUint KTestFileSize = KKilo * 100;
 
  1710 const TUint KTestFileSize = KKilo * 100;
 
  1710 
  1711 
  1711 #define SAFETEST(a)				if(a != KErrNone)\
 
  1712 #define SAFETEST_KErrNone(a)        if(a != KErrNone)\
 
  1712                                         {\
 
  1713                                         {\
 
  1713                                         TheFs.DismountPlugin(KPreModifierPluginName);\
 
  1714                                         TheFs.DismountPlugin(KPreModifierPluginName);\
 
  1714                                         TheFs.RemovePlugin(KPreModifierPluginName);\
 
  1715                                         TheFs.RemovePlugin(KPreModifierPluginName);\
 
  1715                                         test(a == KErrNone);\
 
  1716                                         test_KErrNone(a);\
 
  1716                                         }
 
  1717                                         }
 
  1717 
  1718 
  1718 TInt PluginTestThreadFunction(TAny*)
 
  1719 TInt PluginTestThreadFunction(TAny*)
 
  1719     {
 
  1720     {
 
  1720     RTest test(_L("PluginTestThreadFunction"));
 
  1721     RTest test(_L("PluginTestThreadFunction"));
 
  1721     RFs fs;
 
  1722     RFs fs;
 
  1722     fs.Connect();
 
  1723     fs.Connect();
 
  1723     
  1724     
  1724     TInt r = fs.SetSessionPath(gSessionPath);
 
  1725     TInt r = fs.SetSessionPath(gSessionPath);
 
  1725     test(r == KErrNone);
 
  1726     test_KErrNone(r);
 
  1726     
  1727     
  1727     RFile file;
 
  1728     RFile file;
 
  1728     r = file.Create(fs, KTestFile1, EFileShareAny|EFileWrite);
 
  1729     r = file.Create(fs, KTestFile1, EFileShareAny|EFileWrite);
 
  1729     test(r == KErrNone);
 
  1730     test_KErrNone(r);
 
  1730     r = file.SetSize(KTestFileSize);
 
  1731     r = file.SetSize(KTestFileSize);
 
  1731     test(r == KErrNone);
 
  1732     test_KErrNone(r);
 
  1732     file.Close();
 
  1733     file.Close();
 
  1733       
  1734       
  1734     User::After(5000000); // wait for 5 seconds, to ensure first notification received.
 
  1735     User::After(5000000); // wait for 5 seconds, to ensure first notification received.
 
  1735     
  1736     
  1736     r = fs.Delete(KTestFile1);
 
  1737     r = fs.Delete(KTestFile1);
 
  1737     test(r == KErrNone);
 
  1738     test_KErrNone(r);
 
  1738     
  1739     
  1739     fs.Close();
 
  1740     fs.Close();
 
  1740     return KErrNone;
 
  1741     return KErrNone;
 
  1741     }
 
  1742     }
 
  1742 
  1743 
  1744     {
 
  1745     {
 
  1745     test.Next(_L("Test Disk Space Notify With Plugin"));
 
  1746     test.Next(_L("Test Disk Space Notify With Plugin"));
 
  1746       
  1747       
  1747     TInt drive;
 
  1748     TInt drive;
 
  1748     TInt r = RFs::CharToDrive(gSessionPath[0],drive);
 
  1749     TInt r = RFs::CharToDrive(gSessionPath[0],drive);
 
  1749     SAFETEST(r);
 
  1750     SAFETEST_KErrNone(r);
 
  1750     Format(drive);
 
  1751     Format(drive);
 
  1751     
  1752     
  1752     r = TheFs.MkDirAll(gSessionPath);
 
  1753     r = TheFs.MkDirAll(gSessionPath);
 
  1753     SAFETEST(r);
 
  1754     SAFETEST_KErrNone(r);
 
  1754      
  1755      
  1755     r = TheFs.AddPlugin(KPreModifierPluginFileName);
 
  1756     r = TheFs.AddPlugin(KPreModifierPluginFileName);
 
  1756     SAFETEST(r);
 
  1757     SAFETEST_KErrNone(r);
 
  1757 
  1758 
  1758     r = TheFs.MountPlugin(KPreModifierPluginName);
 
  1759     r = TheFs.MountPlugin(KPreModifierPluginName);
 
  1759     SAFETEST(r);
 
  1760     SAFETEST_KErrNone(r);
 
  1760     
  1761     
  1761     TInt64 free = FreeDiskSpace(drive);
 
  1762     TInt64 free = FreeDiskSpace(drive);
 
  1762     TInt64 threshold = free - KTestFileSize + 1;
 
  1763     TInt64 threshold = free - KTestFileSize + 1;
 
  1763     
  1764     
  1764     TRequestStatus status;
 
  1765     TRequestStatus status;
 
  1766     
  1767     
  1767     TheFs.NotifyDiskSpace(threshold, drive, status);
 
  1768     TheFs.NotifyDiskSpace(threshold, drive, status);
 
  1768     
  1769     
  1769     RThread thread;
 
  1770     RThread thread;
 
  1770     r = thread.Create(_L("PluginTestThread"), PluginTestThreadFunction, KStackSize, KHeapSize, KHeapSize, NULL);
 
  1771     r = thread.Create(_L("PluginTestThread"), PluginTestThreadFunction, KStackSize, KHeapSize, KHeapSize, NULL);
 
  1771     SAFETEST(r);
 
  1772     SAFETEST_KErrNone(r);
 
  1772     thread.Logon(statusDeath);
 
  1773     thread.Logon(statusDeath);
 
  1773     thread.Resume();
 
  1774     thread.Resume();
 
  1774     
  1775     
  1775     User::WaitForRequest(status);
 
  1776     User::WaitForRequest(status);
 
  1776     SAFETEST(status.Int());
 
  1777     SAFETEST_KErrNone(status.Int());
 
  1777     
  1778     
  1778     TheFs.NotifyDiskSpace(threshold, drive, status);
 
  1779     TheFs.NotifyDiskSpace(threshold, drive, status);
 
  1779     User::WaitForRequest(status);
 
  1780     User::WaitForRequest(status);
 
  1780     SAFETEST(status.Int());
 
  1781     SAFETEST_KErrNone(status.Int());
 
  1781     
  1782     
  1782     User::WaitForRequest(statusDeath);
 
  1783     User::WaitForRequest(statusDeath);
 
  1783     SAFETEST(statusDeath.Int());
 
  1784     SAFETEST_KErrNone(statusDeath.Int());
 
  1784     thread.Close();
 
  1785     thread.Close();
 
  1785     
  1786     
  1786     r = TheFs.DismountPlugin(KPreModifierPluginName);
 
  1787     r = TheFs.DismountPlugin(KPreModifierPluginName);
 
  1787     SAFETEST(r);
 
  1788     SAFETEST_KErrNone(r);
 
  1788 
  1789 
  1789     r = TheFs.RemovePlugin(KPreModifierPluginName);
 
  1790     r = TheFs.RemovePlugin(KPreModifierPluginName);
 
  1790     SAFETEST(r);
 
  1791     SAFETEST_KErrNone(r);
 
  1791 
  1792 
  1792     Format(drive);
 
  1793     Format(drive);
 
  1793     }
 
  1794     }
 
  1794 
  1795 
  1795 GLDEF_C void CallTestsL()
 
  1796 GLDEF_C void CallTestsL()
 
  1828 #endif
 
  1829 #endif
 
  1829 		return;
 
  1830 		return;
 
  1830 		}
 
  1831 		}
 
  1831 	//Test uses C drive as secondary drive so test can't be tested on that drive
 
  1832 	//Test uses C drive as secondary drive so test can't be tested on that drive
 
  1832 	r = TheFs.CharToDrive(gSessionPath[0], driveNumber);
 
  1833 	r = TheFs.CharToDrive(gSessionPath[0], driveNumber);
 
  1833 	test(r == KErrNone);
 
  1834 	test_KErrNone(r);
 
  1834 	if(driveNumber == EDriveC)
 
  1835 	if(driveNumber == EDriveC)
 
  1835 		{
 
  1836 		{
 
  1836 		test.Printf(_L("Test uses C drive as secondary drive so test can't be test on C drive, test will exit"));
 
  1837 		test.Printf(_L("Test uses C drive as secondary drive so test can't be test on C drive, test will exit"));
 
  1837 		return;
 
  1838 		return;
 
  1838 		}
 
  1839 		}
MCL/sf/os/kernelhwsrv