Mercurial Mercurial > oss > FCL > 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_file64bit.cpp
branchRCL_3
changeset 257 3e88ff8f41d5
parent 256 c1f20ce4abcf
equal deleted inserted replaced
256:c1f20ce4abcf 257:3e88ff8f41d5 
    23 // // .. etc
 
    23 // // .. etc
 
    24 // 
    24 // 
    25 //
 
    25 //
 
    26 
    26 
    27 
    27 
    28 #define __E32TEST_EXTENSION__
 
       
    29 #include <f32file.h>
 
    28 #include <f32file.h>
 
    30 #include <e32test.h>
 
    29 #include <e32test.h>
 
    31 #include <e32svr.h>
 
    30 #include <e32svr.h>
 
    32 #include "t_server.h"
 
    31 #include "t_server.h"
 
    33 #include "t_file64bit.h"
 
    32 #include "t_file64bit.h"
 
    56 	TInt r;
 
    55 	TInt r;
 
    57     const TUint KBufSize = 256*K1KiloByte;
 
    56     const TUint KBufSize = 256*K1KiloByte;
 
    58     RBuf8 buf;
 
    57     RBuf8 buf;
 
    59     
    58     
    60     r = buf.CreateMax(KBufSize);
 
    59     r = buf.CreateMax(KBufSize);
 
    61     test_KErrNone(r);
 
    60     test(r == KErrNone);
 
    62 
    61 
    63     RFile64 file;
 
    62     RFile64 file;
 
    64 	TFileName fileName;
 
    63 	TFileName fileName;
 
    65 	fileName.Append(gDriveToTest);
 
    64 	fileName.Append(gDriveToTest);
 
    66 	fileName.Append(KTestPath);
 
    65 	fileName.Append(KTestPath);
 
    67 	fileName.Append(_L("File4GBMinusOne.txt"));
 
    66 	fileName.Append(_L("File4GBMinusOne.txt"));
 
    68 	r = file.Replace(TheFs,fileName, EFileWrite);
 
    67 	r = file.Replace(TheFs,fileName, EFileWrite);
 
    69 	test_KErrNone(r);
 
    68 	test(r == KErrNone);
 
    70 	
    69 	
    71     r = file.SetSize(K4GBMinusOne);
 
    70     r = file.SetSize(K4GBMinusOne);
 
    72 	test_KErrNone(r);
 
    71 	test(r == KErrNone);
 
    73 	
    72 	
    74 	TInt64 nNumberOfBytesToWrite = 0;
 
    73 	TInt64 nNumberOfBytesToWrite = 0;
 
    75 	TInt64 nNumberOfBytesWritten = 0;
 
    74 	TInt64 nNumberOfBytesWritten = 0;
 
    76 	for (TInt64 pos = 0; pos < K4GBMinusOne; pos += nNumberOfBytesWritten)
 
    75 	for (TInt64 pos = 0; pos < K4GBMinusOne; pos += nNumberOfBytesWritten)
 
    77 		{
 
    76 		{
 
    88 		
    87 		
    89         nNumberOfBytesWritten = nNumberOfBytesToWrite; 
    88         nNumberOfBytesWritten = nNumberOfBytesToWrite; 
    90 		}
 
    89 		}
 
    91 	
    90 	
    92 	r = file.Flush();
 
    91 	r = file.Flush();
 
    93 	test_KErrNone(r);
 
    92 	test(r == KErrNone);
 
    94 	test.Printf(_L("\nFile writing is completed!!"));
 
    93 	test.Printf(_L("\nFile writing is completed!!"));
 
    95 	
    94 	
    96 	
    95 	
    97 	file.Close();
 
    96 	file.Close();
 
    98 	
    97 	
   176 // Replaces a single file with another
 
   175 // Replaces a single file with another
 
   177 //
 
   176 //
 
   178 	{
 
   177 	{
 
   179 	test.Printf(_L("%S File Replaced with %S\n"),&anOldName,&aNewName);\
 
   178 	test.Printf(_L("%S File Replaced with %S\n"),&anOldName,&aNewName);\
 
   180 	TInt r = TheFs.Replace(anOldName,aNewName);
 
   179 	TInt r = TheFs.Replace(anOldName,aNewName);
 
   181 	test_KErrNone(r);
 
   180 	test(r == KErrNone);
 
   182 	return(*this);
 
   181 	return(*this);
 
   183 	}
 
   182 	}
 
   184 	
   183 	
   185 RFsTest& RFsTest::ReadFileSection(const TDesC& aName, TInt64 aPos,TDes8& aBuffer,TInt aLen)
 
   184 RFsTest& RFsTest::ReadFileSection(const TDesC& aName, TInt64 aPos,TDes8& aBuffer,TInt aLen)
 
   186 //
 
   185 //
 
   189 	{
 
   188 	{
 
   190 	test.Printf(_L("Read File Section %S\n"),&aName);
 
   189 	test.Printf(_L("Read File Section %S\n"),&aName);
 
   191 	TInt r = TheFs.ReadFileSection(aName,aPos,aBuffer,aLen);
 
   190 	TInt r = TheFs.ReadFileSection(aName,aPos,aBuffer,aLen);
 
   192 	TInt len = aBuffer.Length();
 
   191 	TInt len = aBuffer.Length();
 
   193 	
   192 	
   194 	test_KErrNone(r);
 
   193 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   195 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse && aPos >= K4GB) 
   194 		{
 
   196 		test(len == 0);
 
   195 		if(aPos < K4GB) 
       
   196 			test(r == KErrNone);
 
       
   197 		else
 
       
   198 			{
 
       
   199 			test(r == KErrNone);
 
       
   200 			test(len == 0);				
       
   201 			}
 
       
   202 		}
 
       
   203 	else
 
       
   204 		{
 
       
   205 		test (r == KErrNone);	
       
   206 		}
 
   197 	return(*this);
 
   207 	return(*this);
 
   198 	}
 
   208 	}
 
   199 	
   209 	
   200 	
   210 	
   201 RFsTest& RFsTest::GetDir(const TDesC &aName, TUint anEntryAttMask, TUint anEntrySortKey, CDir *&anEntryList)
 
   211 RFsTest& RFsTest::GetDir(const TDesC &aName, TUint anEntryAttMask, TUint anEntrySortKey, CDir *&anEntryList)
 
   203 // Gets a filtered list of a directory's contents.
 
   213 // Gets a filtered list of a directory's contents.
 
   204 //
 
   214 //
 
   205 	{
 
   215 	{
 
   206 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);	
   216 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);	
   207 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList);
 
   217 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList);
 
   208 	test_KErrNone(r);
 
   218 	test(r == KErrNone);
 
   209 	return(*this);
 
   219 	return(*this);
 
   210 	}
 
   220 	}
 
   211 
   221 
   212 RFsTest& RFsTest::GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList)
 
   222 RFsTest& RFsTest::GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList)
 
   213 //
 
   223 //
 
   214 // Gets a filtered list of the directory and the file entries contained in a directory and a
 
   224 // Gets a filtered list of the directory and the file entries contained in a directory and a
 
   215 // list of the directory entries only.
 
   225 // list of the directory entries only.
 
   216 	{
 
   226 	{
 
   217 	test.Printf(_L("Name of the directory for which directory and file listing is required %S\n"),&aName);	
   227 	test.Printf(_L("Name of the directory for which directory and file listing is required %S\n"),&aName);	
   218 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList,aDirList);
 
   228 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList,aDirList);
 
   219 	test_KErrNone(r);
 
   229 	test(r == KErrNone);
 
   220 	return(*this);
 
   230 	return(*this);
 
   221 	}
 
   231 	}
 
   222 
   232 
   223 RFsTest& RFsTest::GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList)
 
   233 RFsTest& RFsTest::GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList)
 
   224 //
 
   234 //
 
   225 // Gets a filtered list of directory contents by UID type.
 
   235 // Gets a filtered list of directory contents by UID type.
 
   226 //
 
   236 //
 
   227 	{
 
   237 	{
 
   228 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);	
   238 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);	
   229 	TInt r = TheFs.GetDir(aName,anEntryUid,anEntrySortKey,aFileList);
 
   239 	TInt r = TheFs.GetDir(aName,anEntryUid,anEntrySortKey,aFileList);
 
   230 	test_KErrNone(r);
 
   240 	test(r == KErrNone);
 
   231 	return(*this);	
   241 	return(*this);	
   232 	}
 
   242 	}
 
   233 		
   243 		
   234 	
   244 	
   235 RFileTest::RFileTest(const TDesC& aName)
 
   245 RFileTest::RFileTest(const TDesC& aName)
 
   244 // Creates and opens a new file for writing, if the file already exists an error is returned
 
   254 // Creates and opens a new file for writing, if the file already exists an error is returned
 
   245 //
 
   255 //
 
   246 	{
 
   256 	{
 
   247 	test.Printf(_L("%S create %S in %d Mode\n"),&iName,&aName,aFileMode);
 
   257 	test.Printf(_L("%S create %S in %d Mode\n"),&iName,&aName,aFileMode);
 
   248 	TInt r = RFile64::Create(TheFs,aName,aFileMode);
 
   258 	TInt r = RFile64::Create(TheFs,aName,aFileMode);
 
   249 	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 
   259 	test(r == KErrNone || r == KErrAlreadyExists);
 
   250 	return(*this);		
   260 	return(*this);		
   251 	}
 
   261 	}
 
   252 	
   262 	
   253 RFileTest& RFileTest::Replace(const TDesC& aName)
 
   263 RFileTest& RFileTest::Replace(const TDesC& aName)
 
   254 //
 
   264 //
 
   256 // if it exists or cretaing a new file if it does not exist.
 
   266 // if it exists or cretaing a new file if it does not exist.
 
   257 //
 
   267 //
 
   258 	{
 
   268 	{
 
   259 	test.Printf(_L("%S replace %S\n"),&iName,&aName);
 
   269 	test.Printf(_L("%S replace %S\n"),&iName,&aName);
 
   260 	TInt r = RFile64::Replace(TheFs,aName,EFileStream|EFileWrite);
 
   270 	TInt r = RFile64::Replace(TheFs,aName,EFileStream|EFileWrite);
 
   261 	test_KErrNone(r);
 
   271 	test(r == KErrNone);
 
   262 	return(*this);
 
   272 	return(*this);
 
   263 	}
 
   273 	}
 
   264 
   274 
   265 RFileTest& RFileTest::Replace(const TDesC& aName, TUint aFileMode)
 
   275 RFileTest& RFileTest::Replace(const TDesC& aName, TUint aFileMode)
 
   266 //
 
   276 //
 
   268 // if it exists or cretaing a new file if it does not exist.
 
   278 // if it exists or cretaing a new file if it does not exist.
 
   269 //
 
   279 //
 
   270 	{
 
   280 	{
 
   271 	test.Printf(_L("%S replace %S in %d Mode\n"),&iName,&aName, aFileMode);
 
   281 	test.Printf(_L("%S replace %S in %d Mode\n"),&iName,&aName, aFileMode);
 
   272 	TInt r = RFile64::Replace(TheFs,aName,aFileMode);
 
   282 	TInt r = RFile64::Replace(TheFs,aName,aFileMode);
 
   273 	test_Value(r, r == KErrNone || r == KErrBadName);
 
   283 	if (r == KErrNone)
 
       
   284 		test(r == KErrNone);
 
       
   285 	else
 
       
   286 		test(r == KErrBadName);
 
   274 	return(*this);		
   287 	return(*this);		
   275 	}
 
   288 	}
 
   276 	
   289 	
   277 RFileTest& RFileTest::Open(const TDesC& aName)
 
   290 RFileTest& RFileTest::Open(const TDesC& aName)
 
   278 //
 
   291 //
 
   279 // Open a existing file for reading and writing in shared access mode.
 
   292 // Open a existing file for reading and writing in shared access mode.
 
   280 //
 
   293 //
 
   281 	{
 
   294 	{
 
   282 	test.Printf(_L("%S open %S\n"),&iName,&aName);
 
   295 	test.Printf(_L("%S open %S\n"),&iName,&aName);
 
   283 	TInt r = RFile64::Open(TheFs,aName,EFileWrite|EFileShareAny);
 
   296 	TInt r = RFile64::Open(TheFs,aName,EFileWrite|EFileShareAny);
 
   284 	test_KErrNone(r);
 
   297 	test(r == KErrNone);
 
   285 	return(*this);
 
   298 	return(*this);
 
   286 	}
 
   299 	}
 
   287 
   300 
   288 RFileTest& RFileTest::Open(const TDesC& aName, TUint aFileMode)
 
   301 RFileTest& RFileTest::Open(const TDesC& aName, TUint aFileMode)
 
   289 //
 
   302 //
 
   290 // Opens an existing file using aFileMode.
 
   303 // Opens an existing file using aFileMode.
 
   291 //
 
   304 //
 
   292 	{
 
   305 	{
 
   293 	test.Printf(_L("%S open %S in %d Mode\n"),&iName,&aName, aFileMode);
 
   306 	test.Printf(_L("%S open %S in %d Mode\n"),&iName,&aName, aFileMode);
 
   294 	TInt r = RFile64::Open(TheFs,aName,aFileMode);
 
   307 	TInt r = RFile64::Open(TheFs,aName,aFileMode);
 
   295 	test_KErrNone(r);
 
   308 	test(r == KErrNone);
 
   296 	return(*this);
 
   309 	return(*this);
 
   297 	}
 
   310 	}
 
   298 
   311 
   299 RFileTest& RFileTest::Temp(const TDesC& aPath,TFileName& aName,TUint aFileMode)
 
   312 RFileTest& RFileTest::Temp(const TDesC& aPath,TFileName& aName,TUint aFileMode)
 
   300 //
 
   313 //
 
   301 // Creates and opens a temporary file with a unique name for writing and reading.
 
   314 // Creates and opens a temporary file with a unique name for writing and reading.
 
   302 //
 
   315 //
 
   303 	{
 
   316 	{
 
   304 	test.Printf(_L("%S Temp file %S in %d Mode\n"),&iName,&aName, aFileMode);
 
   317 	test.Printf(_L("%S Temp file %S in %d Mode\n"),&iName,&aName, aFileMode);
 
   305 	TInt r = RFile64::Temp(TheFs,aPath,aName,aFileMode);	
   318 	TInt r = RFile64::Temp(TheFs,aPath,aName,aFileMode);	
   306 	test_KErrNone(r);
 
   319 	test(r == KErrNone);
 
   307 	return(*this);
 
   320 	return(*this);
 
   308 	}
 
   321 	}
 
   309 	
   322 	
   310 void RFileTest::Close()
 
   323 void RFileTest::Close()
 
   311 //
 
   324 //
 
   320 // Set a lock on the file. Expected not to fail.
 
   333 // Set a lock on the file. Expected not to fail.
 
   321 //
 
   334 //
 
   322 	{
 
   335 	{
 
   323 	test.Printf(_L("%S lock   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   336 	test.Printf(_L("%S lock   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   324 	TInt r = RFile64::Lock(aPos,aLen);
 
   337 	TInt r = RFile64::Lock(aPos,aLen);
 
   325 	test_KErrNone(r);
 
   338 	test(r == KErrNone);
 
   326 	return(*this);
 
   339 	return(*this);
 
   327 	}
 
   340 	}
 
   328 
   341 
   329 RFileTest& RFileTest::LockE(TInt64 aPos, TInt64 aLen)
 
   342 RFileTest& RFileTest::LockE(TInt64 aPos, TInt64 aLen)
 
   330 //
 
   343 //
 
   331 // Set a lock on the file. Expected to fail.
 
   344 // Set a lock on the file. Expected to fail.
 
   332 //
 
   345 //
 
   333 	{
 
   346 	{
 
   334 	test.Printf(_L("%S lockE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   347 	test.Printf(_L("%S lockE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   335 	TInt r = RFile64::Lock(aPos,aLen);
 
   348 	TInt r = RFile64::Lock(aPos,aLen);
 
   336 	test_Value(r, r == KErrLocked);
 
   349 	test(r == KErrLocked);
 
   337 	return(*this);
 
   350 	return(*this);
 
   338 	}
 
   351 	}
 
   339 
   352 
   340 RFileTest& RFileTest::UnLock(TInt64 aPos, TInt64 aLen)
 
   353 RFileTest& RFileTest::UnLock(TInt64 aPos, TInt64 aLen)
 
   341 //
 
   354 //
 
   342 // Unlock the file. Expected not to fail.
 
   355 // Unlock the file. Expected not to fail.
 
   343 //
 
   356 //
 
   344 	{
 
   357 	{
 
   345 	test.Printf(_L("%S ulock  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   358 	test.Printf(_L("%S ulock  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   346 	TInt r = RFile64::UnLock(aPos,aLen);
 
   359 	TInt r = RFile64::UnLock(aPos,aLen);
 
   347 	test_KErrNone(r);
 
   360 	test(r == KErrNone);
 
   348 	return(*this);
 
   361 	return(*this);
 
   349 	}
 
   362 	}
 
   350 
   363 
   351 RFileTest& RFileTest::UnLockE(TInt64 aPos, TInt64 aLen)
 
   364 RFileTest& RFileTest::UnLockE(TInt64 aPos, TInt64 aLen)
 
   352 //
 
   365 //
 
   353 // Unlock the file. Expected to fail.
 
   366 // Unlock the file. Expected to fail.
 
   354 //
 
   367 //
 
   355 	{
 
   368 	{
 
   356 	test.Printf(_L("%S ulockE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   369 	test.Printf(_L("%S ulockE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   357 	TInt r = RFile64::UnLock(aPos,aLen);
 
   370 	TInt r = RFile64::UnLock(aPos,aLen);
 
   358 	test_Value(r, r == KErrNotFound);
 
   371 	test(r == KErrNotFound);
 
   359 	return(*this);
 
   372 	return(*this);
 
   360 	}
 
   373 	}
 
   361 
   374 
   362 RFileTest& RFileTest::Write(const TDesC8& aDes)
 
   375 RFileTest& RFileTest::Write(const TDesC8& aDes)
 
   363 //
 
   376 //
 
   376 		
   389 		
   377 	
   390 	
   378 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   391 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   379 		{
 
   392 		{
 
   380 		if((seekPos + aDes.Length()) < K4GB)
 
   393 		if((seekPos + aDes.Length()) < K4GB)
 
   381 			{
 
   394 			test(r == KErrNone);
 
   382 			test_KErrNone(r);
 
       
   383 			}
 
       
   384 		else
 
   395 		else
 
   385 			{
 
   396 			test(r == KErrNotSupported);
 
   386 			test_Value(r, r == KErrNotSupported);
 
       
   387 			}
 
       
   388 		}
 
   397 		}
 
   389 	else
 
   398 	else
 
   390 		{
 
   399 		{
 
   391 		test_KErrNone(r);	
   400 		test (r == KErrNone);	
   392 		}
 
   401 		}
 
   393 	return(*this);
 
   402 	return(*this);
 
   394 	}
 
   403 	}
 
   395 
   404 
   396 RFileTest& RFileTest::Write(const TDesC8 &aDes, TRequestStatus &aStatus)
 
   405 RFileTest& RFileTest::Write(const TDesC8 &aDes, TRequestStatus &aStatus)
 
   412 		User::WaitForRequest(aStatus);
 
   421 		User::WaitForRequest(aStatus);
 
   413 		}
 
   422 		}
 
   414 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   423 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   415 		{
 
   424 		{
 
   416 		if((seekPos + aDes.Length()) < K4GB)
 
   425 		if((seekPos + aDes.Length()) < K4GB)
 
   417 			{
 
       
   418 			test(aStatus.Int() == KErrNone);
 
   426 			test(aStatus.Int() == KErrNone);
 
   419 			}
 
       
   420 		else
 
   427 		else
 
   421 			{
 
       
   422 			test(aStatus.Int() == KErrNotSupported);
 
   428 			test(aStatus.Int() == KErrNotSupported);
 
   423 			}
 
   429 		
   424 		}
 
   430 		}
 
   425 	else
 
   431 	else
 
   426 		{
 
   432 		{
 
   427 		test(aStatus.Int() == KErrNone);
 
   433 		test(aStatus.Int() == KErrNone);
 
   428 		}
 
   434 		}
 
   444 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   450 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   445 		r = RFile64::Flush(); 		
   451 		r = RFile64::Flush(); 		
   446 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   452 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   447 		{
 
   453 		{
 
   448 		if((seekPos + aLength) < K4GB)
 
   454 		if((seekPos + aLength) < K4GB)
 
   449 			{
 
   455 			test(r == KErrNone);
 
   450 			test_KErrNone(r);
 
       
   451 			}
 
       
   452 		else
 
   456 		else
 
   453 			{
 
   457 			test(r == KErrNotSupported);
 
   454 			test_Value(r, r == KErrNotSupported);
 
       
   455 			}
 
       
   456 		}
 
   458 		}
 
   457 	else
 
   459 	else
 
   458 		{
 
   460 		{
 
   459 		test_KErrNone(r);
 
   461 		test(r == KErrNone);
 
   460 		}
 
   462 		}
 
   461 	return(*this);	
   463 	return(*this);	
   462 	}	
   464 	}	
   463 
   465 
   464 RFileTest& RFileTest::Write(const TDesC8& aDes, TInt aLength, TRequestStatus &aStatus)	
   466 RFileTest& RFileTest::Write(const TDesC8& aDes, TInt aLength, TRequestStatus &aStatus)	
   504 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   506 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   505 		r = RFile64::Flush();
 
   507 		r = RFile64::Flush();
 
   506 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   508 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   507 		{
 
   509 		{
 
   508 		if ((aPos + aDes.Length()) < K4GB)
 
   510 		if ((aPos + aDes.Length()) < K4GB)
 
   509 			{
 
   511 			test(r == KErrNone);
 
   510 			test_KErrNone(r);
 
       
   511 			}
 
       
   512 		else
 
   512 		else
 
   513 			{
 
   513 			test(r == KErrNotSupported);
 
   514 			test_Value(r, r == KErrNotSupported);
 
       
   515 			}
 
       
   516 		}
 
   514 		}
 
   517 	else
 
   515 	else
 
   518 		{
 
   516 		{
 
   519 		test_KErrNone(r);
 
   517 		test(r == KErrNone);
 
   520 		}
 
   518 		}
 
   521 	return(*this);
 
   519 	return(*this);
 
   522 	}
 
   520 	}
 
   523 
   521 
   524 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes)
 
   522 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes)
 
   529 	{
 
   527 	{
 
   530 	test.Printf(_L("%S write  %08x\n"),&iName,aPos);
 
   528 	test.Printf(_L("%S write  %08x\n"),&iName,aPos);
 
   531 	TInt r = RFile64::Write(aPos,aDes);
 
   529 	TInt r = RFile64::Write(aPos,aDes);
 
   532 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   530 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   533 		r = RFile64::Flush();
 
   531 		r = RFile64::Flush();
 
   534 	test_KErrNone(r);
 
   532 	test(r == KErrNone);
 
   535 	return(*this);
 
   533 	return(*this);
 
   536 	}
 
   534 	}
 
   537 
   535 
   538 
   536 
   539 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen)
 
   537 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen)
 
   548 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   546 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   549 		{
 
   547 		{
 
   550 		if ((aPos + aLen) < K4GB)
 
   548 		if ((aPos + aLen) < K4GB)
 
   551 			{
 
   549 			{
 
   552 			if (aLen < 0)
 
   550 			if (aLen < 0)
 
   553 				{
 
   551 				test(r == KErrArgument);
 
   554 				test_Value(r, r == KErrArgument);
 
       
   555 				}
 
       
   556 			else
 
   552 			else
 
   557 				{
 
   553 				test(r == KErrNone);
 
   558 				test_KErrNone(r);
 
       
   559 				}
 
       
   560 			}
 
   554 			}
 
   561 		else
 
   555 		else
 
   562 			{
 
   556 			test(r == KErrNotSupported);
 
   563 			test_Value(r, r == KErrNotSupported);
 
       
   564 			}
 
       
   565 		}
 
   557 		}
 
   566 	else
 
   558 	else
 
   567 		{
 
   559 		{
 
   568 		if (aLen < 0)
 
   560 		if (aLen < 0)
 
   569 			{
 
   561 			test(r == KErrArgument);
 
   570 			test_Value(r, r == KErrArgument);
 
       
   571 			}
 
       
   572 		else
 
   562 		else
 
   573 			{
 
   563 			test(r == KErrNone);
 
   574 			test_KErrNone(r);
 
       
   575 			}
 
       
   576 		}
 
   564 		}
 
   577 	return(*this);
 
   565 	return(*this);
 
   578 	}
 
   566 	}
 
   579 
   567 
   580 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes, TInt aLen)
 
   568 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes, TInt aLen)
 
   585 	{
 
   573 	{
 
   586 	test.Printf(_L("%S write  %08x-%08x\n"),&iName,aPos,aPos+aLen-1);
 
   574 	test.Printf(_L("%S write  %08x-%08x\n"),&iName,aPos,aPos+aLen-1);
 
   587 	TInt r = RFile64::Write(aPos,aDes,aLen);
 
   575 	TInt r = RFile64::Write(aPos,aDes,aLen);
 
   588 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   576 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 
   589 		r = RFile64::Flush();
 
   577 		r = RFile64::Flush();
 
   590 	test_KErrNone(r);
 
   578 	test(r == KErrNone);
 
   591 	return(*this);
 
   579 	return(*this);
 
   592 	}
 
   580 	}
 
   593 
   581 
   594 
   582 
   595 RFileTest& RFileTest::WriteE(TInt64 aPos, const TDesC8& aDes, TInt aLen)
 
   583 RFileTest& RFileTest::WriteE(TInt64 aPos, const TDesC8& aDes, TInt aLen)
 
   597 // Write to the file. Expected to fail.
 
   585 // Write to the file. Expected to fail.
 
   598 //
 
   586 //
 
   599 	{
 
   587 	{
 
   600 	test.Printf(_L("%S writeE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   588 	test.Printf(_L("%S writeE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   601 	TInt r = RFile64::Write(aPos,aDes,aLen);
 
   589 	TInt r = RFile64::Write(aPos,aDes,aLen);
 
   602 	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrLocked);
 
   590 	if (aLen < 0)
 
       
   591 		test(r == KErrArgument);
 
       
   592 	else
 
       
   593 		test(r == KErrLocked);
 
   603 	return(*this);
 
   594 	return(*this);
 
   604 	}
 
   595 	}
 
   605 
   596 
   606 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen, TRequestStatus &aStatus)
 
   597 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen, TRequestStatus &aStatus)
 
   607 // 
   598 // 
   708 // Read from the file. Expected not to fail (Synchronous).
 
   699 // Read from the file. Expected not to fail (Synchronous).
 
   709 //
 
   700 //
 
   710 	{
 
   701 	{
 
   711 	test.Printf(_L("%S read \n"),&iName);
 
   702 	test.Printf(_L("%S read \n"),&iName);
 
   712 	TInt r = RFile64::Read(aDes);
 
   703 	TInt r = RFile64::Read(aDes);
 
   713 	test_KErrNone(r);
 
   704 	test(r == KErrNone);
 
   714 	return(*this);
 
   705 	return(*this);
 
   715 	}
 
   706 	}
 
   716 
   707 
   717 RFileTest& RFileTest::Read(TDes8& aDes, TRequestStatus& aStatus) 
   708 RFileTest& RFileTest::Read(TDes8& aDes, TRequestStatus& aStatus) 
   718 //
 
   709 //
 
   777 // Read from the file. Expected not to fail (Synchronous).
 
   768 // Read from the file. Expected not to fail (Synchronous).
 
   778 //
 
   769 //
 
   779 	{
 
   770 	{
 
   780 	test.Printf(_L("%S read 0x%08x bytes\n"),&iName,aLen);
 
   771 	test.Printf(_L("%S read 0x%08x bytes\n"),&iName,aLen);
 
   781 	TInt r = RFile64::Read(aDes,aLen);
 
   772 	TInt r = RFile64::Read(aDes,aLen);
 
   782 	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrNone);
 
   773 	if(aLen < 0)
 
       
   774 		test(r == KErrArgument);
 
       
   775 	else
 
       
   776 		test(r == KErrNone);
 
   783 	return(*this);
 
   777 	return(*this);
 
   784 	}
 
   778 	}
 
   785 	
   779 	
   786 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen) 
   780 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen) 
   787 //
 
   781 //
 
   789 //
 
   783 //
 
   790 	{
 
   784 	{
 
   791 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   785 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   792 	TInt r = RFile64::Read(aPos,aDes,aLen);
 
   786 	TInt r = RFile64::Read(aPos,aDes,aLen);
 
   793 	TInt len = aDes.Length();
 
   787 	TInt len = aDes.Length();
 
   794 	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrNone);
 
   788 	if(aLen < 0)
 
       
   789 		test(r == KErrArgument);
 
       
   790 	else 
       
   791 		test(r == KErrNone);
 
   795 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   792 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   796 		{	
   793 		{	
   797 		if(aPos >= K4GB) 
   794 		if(aPos >= K4GB) 
   798 			test(len == 0);
 
   795 			test(len == 0);
 
   799 		}
 
   796 		}
 
   805 // Reads the specified number of bytes from the file at a specified offset. Expected to fail.
 
   802 // Reads the specified number of bytes from the file at a specified offset. Expected to fail.
 
   806 //
 
   803 //
 
   807 	{
 
   804 	{
 
   808 	test.Printf(_L("%S readE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   805 	test.Printf(_L("%S readE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   809 	TInt r = RFile64::Read(aPos,aDes,aLen);
 
   806 	TInt r = RFile64::Read(aPos,aDes,aLen);
 
   810 	test_Value(r, r == KErrLocked);
 
   807 	test(r == KErrLocked);
 
   811 	return(*this);
 
   808 	return(*this);
 
   812 	}
 
   809 	}
 
   813 
   810 
   814 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus) 
   811 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus) 
   815 //
 
   812 //
 
   837 // Reads from the file at the specfied offset with in the file (Synchronous).
 
   834 // Reads from the file at the specfied offset with in the file (Synchronous).
 
   838 //
 
   835 //
 
   839 	{
 
   836 	{
 
   840 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);
 
   837 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);
 
   841 	TInt r = RFile64::Read(aPos,aDes);
 
   838 	TInt r = RFile64::Read(aPos,aDes);
 
   842 	test_KErrNone(r);
 
   839 	test(r == KErrNone);
 
   843 	return(*this);	
   840 	return(*this);	
   844 	}
 
   841 	}
 
   845 
   842 
   846 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes)
 
   843 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes)
 
   847 //
 
   844 //
 
   849 // Offset is specified as a TUint value.
 
   846 // Offset is specified as a TUint value.
 
   850 //
 
   847 //
 
   851 	{
 
   848 	{
 
   852 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);
 
   849 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);
 
   853 	TInt r = RFile64::Read(aPos,aDes);
 
   850 	TInt r = RFile64::Read(aPos,aDes);
 
   854 	test_KErrNone(r);
 
   851 	test(r == KErrNone);
 
   855 	return(*this);	
   852 	return(*this);	
   856 	}
 
   853 	}
 
   857 
   854 
   858 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes,TRequestStatus& aStatus)
 
   855 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes,TRequestStatus& aStatus)
 
   859 //
 
   856 //
 
   874 // Offset is specified as a TUint value.
 
   871 // Offset is specified as a TUint value.
 
   875 //
 
   872 //
 
   876 	{
 
   873 	{
 
   877 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   874 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 
   878 	TInt r = RFile64::Read(aPos,aDes,aLen);
 
   875 	TInt r = RFile64::Read(aPos,aDes,aLen);
 
   879 	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrNone);
 
   876 	if(aLen < 0)
 
       
   877 		test(r == KErrArgument);
 
       
   878 	else 
       
   879 		test(r == KErrNone);
 
   880 	return(*this);
 
   880 	return(*this);
 
   881 	}
 
   881 	}
 
   882 
   882 
   883 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus) 
   883 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus) 
   884 //
 
   884 //
 
   917 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);
 
   917 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);
 
   918 	TInt r = RFile64::SetSize(aSize);
 
   918 	TInt r = RFile64::SetSize(aSize);
 
   919 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   919 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   920 		{
 
   920 		{
 
   921 		if(aSize < K4GB)
 
   921 		if(aSize < K4GB)
 
   922 			{
 
   922 			test(r == KErrNone);
 
   923 			test_KErrNone(r);
 
       
   924 			}
 
       
   925 		else
 
   923 		else
 
   926 			{
 
   924 			test(r == KErrNotSupported);
 
   927 			test_Value(r, r == KErrNotSupported);
 
       
   928 			}
 
       
   929 		}
 
   925 		}
 
   930 	else
 
   926 	else
 
   931 		{
 
   927 		{
 
   932 		test_KErrNone(r);
 
   928 		test(r == KErrNone);
 
   933 		}
 
   929 		}
 
   934 	return(*this);
 
   930 	return(*this);
 
   935 	}
 
   931 	}
 
   936 
   932 
   937 RFileTest& RFileTest::SetSizeE(TInt64 aSize)
 
   933 RFileTest& RFileTest::SetSizeE(TInt64 aSize)
 
   939 // Set the size of the file. Expected to fail.
 
   935 // Set the size of the file. Expected to fail.
 
   940 //
 
   936 //
 
   941 	{
 
   937 	{
 
   942 	test.Printf(_L("%S sizeE: 0x%lx\n"),&iName,aSize);
 
   938 	test.Printf(_L("%S sizeE: 0x%lx\n"),&iName,aSize);
 
   943 	TInt r = RFile64::SetSize(aSize);
 
   939 	TInt r = RFile64::SetSize(aSize);
 
   944 	test_Value(r, r == KErrLocked);
 
   940 	test(r == KErrLocked);
 
   945 	return(*this);
 
   941 	return(*this);
 
   946 	}
 
   942 	}
 
   947 
   943 
   948 RFileTest& RFileTest::Size(TInt64& aSize)
 
   944 RFileTest& RFileTest::Size(TInt64& aSize)
 
   949 //
 
   945 //
 
   954 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);
 
   950 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);
 
   955 
   951 
   956     if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   952     if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 
   957 		{
 
   953 		{
 
   958 		if(aSize < K4GB)
 
   954 		if(aSize < K4GB)
 
   959 			{
 
   955 			test(r == KErrNone);
 
   960 			test_KErrNone(r);
 
       
   961 			}
 
       
   962 		else
 
   956 		else
 
   963 			{
 
   957 			test(r == KErrTooBig);
 
   964 			test_Value(r, r == KErrTooBig);
 
       
   965 			}
 
       
   966 		}
 
   958 		}
 
   967 	else
 
   959 	else
 
   968 		{
 
   960 		{
 
   969 		test_KErrNone(r);
 
   961 		test(r == KErrNone);
 
   970 		}
 
   962 		}
 
   971 	return(*this);	
   963 	return(*this);	
   972 
   964 
   973 	}
 
   965 	}
 
   974 RFileTest& RFileTest::Seek(TSeek aMode, TInt64& aPos)
 
   966 RFileTest& RFileTest::Seek(TSeek aMode, TInt64& aPos)
 
   976 // Sets the current file position. Expected not to fail.
 
   968 // Sets the current file position. Expected not to fail.
 
   977 //
 
   969 //
 
   978 	{
 
   970 	{
 
   979 	test.Printf(_L("Seek to pos %LD in %d Mode\n"),aPos, aMode);
 
   971 	test.Printf(_L("Seek to pos %LD in %d Mode\n"),aPos, aMode);
 
   980 	TInt r = RFile64::Seek(aMode, aPos);
 
   972 	TInt r = RFile64::Seek(aMode, aPos);
 
   981 	test_Value(r, r == (aPos < 0) ? KErrArgument : KErrNone);
 
   973 	if(aPos < 0)
 
       
   974 		test(r == KErrArgument);
 
       
   975 	else
 
       
   976 		test(r == KErrNone);
 
   982 	return(*this);	
   977 	return(*this);	
   983 	}
 
   978 	}
 
   984 
   979 
   985 /**
 
   980 /**
 
   986 @SYMTestCaseID      PBASE-T_FILE64BIT-0756
 
   981 @SYMTestCaseID      PBASE-T_FILE64BIT-0756
 
  1015 	TestRFile1.Close();
 
  1010 	TestRFile1.Close();
 
  1016 	
  1011 	
  1017 	
  1012 	
  1018 	test.Next(_L("2GB File: Open"));
 
  1013 	test.Next(_L("2GB File: Open"));
 
  1019 	TInt r = TheFs.Entry(fileName, entry);
 
  1014 	TInt r = TheFs.Entry(fileName, entry);
 
  1020 	test_KErrNone(r);
 
  1015 	test(r == KErrNone);
 
  1021 	test((TUint) entry.iSize == testSize);
 
  1016 	test((TUint) entry.iSize == testSize);
 
  1022 
  1017 
  1023     TestRFile1.Open(fileName, EFileRead);
 
  1018     TestRFile1.Open(fileName, EFileRead);
 
  1024 	
  1019 	
  1025 	
  1020 	
  1026 	TestRFile1.Size(size);
 
  1021 	TestRFile1.Size(size);
 
  1027 	test(size == testSize);
 
  1022 	test(size == testSize);
 
  1028 	
  1023 	
  1029 	TestRFile1.Close();
 
  1024 	TestRFile1.Close();
 
  1030 	r = TheFs.Delete(fileName);
 
  1025 	r = TheFs.Delete(fileName);
 
  1031 	test_KErrNone(r);
 
  1026 	test(r == KErrNone);
 
  1032 	}
 
  1027 	}
 
  1033 
  1028 
  1034 /**
 
  1029 /**
 
  1035 @SYMTestCaseID      PBASE-T_FILE64BIT-0757
 
  1030 @SYMTestCaseID      PBASE-T_FILE64BIT-0757
 
  1036 @SYMTestPriority    High
 
  1031 @SYMTestPriority    High
 
  1063 	TestRFile1.SetSize(testSize);
 
  1058 	TestRFile1.SetSize(testSize);
 
  1064 	TestRFile1.Close();
 
  1059 	TestRFile1.Close();
 
  1065 		
  1060 		
  1066 	test.Next(_L("3GB File: Open"));
 
  1061 	test.Next(_L("3GB File: Open"));
 
  1067 	r = TheFs.Entry(fileName, entry);
 
  1062 	r = TheFs.Entry(fileName, entry);
 
  1068 	test_KErrNone(r);
 
  1063 	test(r == KErrNone);
 
  1069 	test((TUint) entry.iSize == testSize);
 
  1064 	test((TUint) entry.iSize == testSize);
 
  1070 	
  1065 	
  1071 	TestRFile1.Open(fileName,EFileRead);
 
  1066 	TestRFile1.Open(fileName,EFileRead);
 
  1072 	
  1067 	
  1073 	TestRFile1.Size(size);
 
  1068 	TestRFile1.Size(size);
 
  1074 	test(size == testSize);
 
  1069 	test(size == testSize);
 
  1075 	TestRFile1.Close();
 
  1070 	TestRFile1.Close();
 
  1076 	
  1071 	
  1077 	r = TheFs.Delete(fileName);
 
  1072 	r = TheFs.Delete(fileName);
 
  1078 	test_KErrNone(r);
 
  1073 	test(r == KErrNone);
 
  1079 	}
 
  1074 	}
 
  1080 
  1075 
  1081 /**
 
  1076 /**
 
  1082 @SYMTestCaseID      PBASE-T_FILE64BIT-0758
 
  1077 @SYMTestCaseID      PBASE-T_FILE64BIT-0758
 
  1083 @SYMTestPriority    High
 
  1078 @SYMTestPriority    High
 
  1110 	TestRFile1.SetSize(testSize);
 
  1105 	TestRFile1.SetSize(testSize);
 
  1111 	TestRFile1.Close();
 
  1106 	TestRFile1.Close();
 
  1112 	
  1107 	
  1113 	test.Next(_L("4GB-1 File: Open"));
 
  1108 	test.Next(_L("4GB-1 File: Open"));
 
  1114 	r = TheFs.Entry(fileName, entry);
 
  1109 	r = TheFs.Entry(fileName, entry);
 
  1115 	test_KErrNone(r);
 
  1110 	test(r == KErrNone);
 
  1116 	
  1111 	
  1117 	test((TUint) entry.iSize == testSize);
 
  1112 	test((TUint) entry.iSize == testSize);
 
  1118 	
  1113 	
  1119 	TestRFile1.Open(fileName, EFileRead);
 
  1114 	TestRFile1.Open(fileName, EFileRead);
 
  1120 		
  1115 		
  1122 		
  1117 		
  1123 	test(size == testSize);
 
  1118 	test(size == testSize);
 
  1124 	TestRFile1.Close();
 
  1119 	TestRFile1.Close();
 
  1125 	
  1120 	
  1126 	r = TheFs.Delete(fileName);
 
  1121 	r = TheFs.Delete(fileName);
 
  1127 	test_KErrNone(r);
 
  1122 	test(r == KErrNone);
 
  1128 	}
 
  1123 	}
 
  1129 	
  1124 	
  1130 /**
 
  1125 /**
 
  1131 @SYMTestCaseID      PBASE-T_FILE64BIT-0759
 
  1126 @SYMTestCaseID      PBASE-T_FILE64BIT-0759
 
  1132 @SYMTestPriority    High
 
  1127 @SYMTestPriority    High
 
  1159 	TestRFile1.SetSize(testSize);
 
  1154 	TestRFile1.SetSize(testSize);
 
  1160 	TestRFile1.Close();
 
  1155 	TestRFile1.Close();
 
  1161 	
  1156 	
  1162 	test.Next(_L("4GB File: Open"));
 
  1157 	test.Next(_L("4GB File: Open"));
 
  1163 	r = TheFs.Entry(fileName, entry);
 
  1158 	r = TheFs.Entry(fileName, entry);
 
  1164 	test_KErrNone(r);
 
  1159 	test(r == KErrNone);
 
  1165 	
  1160 	
  1166 	if ((TUint) entry.iSize == testSize)
 
  1161 	if ((TUint) entry.iSize == testSize)
 
  1167 		{
 
  1162 		{
 
  1168 		TestRFile1.Open(fileName, EFileRead);
 
  1163 		TestRFile1.Open(fileName, EFileRead);
 
  1169 		TestRFile1.Size(size);
 
  1164 		TestRFile1.Size(size);
 
  1170 		test(size == testSize);
 
  1165 		test(size == testSize);
 
  1171 		TestRFile1.Close();
 
  1166 		TestRFile1.Close();
 
  1172 		}
 
  1167 		}
 
  1173 	
  1168 	
  1174 	r = TheFs.Delete(fileName);
 
  1169 	r = TheFs.Delete(fileName);
 
  1175 	test_KErrNone(r);
 
  1170 	test(r == KErrNone);
 
  1176 		
  1171 		
  1177 	}	
  1172 	}	
  1178 	
  1173 	
  1179 /**
 
  1174 /**
 
  1180 @SYMTestCaseID      PBASE-T_FILE64BIT-0760
 
  1175 @SYMTestCaseID      PBASE-T_FILE64BIT-0760
 
  1257 		}
 
  1252 		}
 
  1258 	TestRFile1.Close();
 
  1253 	TestRFile1.Close();
 
  1259 	
  1254 	
  1260 	RFile64 file64;
 
  1255 	RFile64 file64;
 
  1261 	TInt r = file64.Open(TheFs,fileName,EDeleteOnClose);
 
  1256 	TInt r = file64.Open(TheFs,fileName,EDeleteOnClose);
 
  1262 	test_Value(r, r == KErrArgument);
 
  1257 	test (r == KErrArgument);
 
  1263 	
  1258 	
  1264 	r = TheFs.Delete(fileName);
 
  1259 	r = TheFs.Delete(fileName);
 
  1265 	test_KErrNone(r);
 
  1260 	test(r == KErrNone);
 
  1266 	
  1261 	
  1267 	}
 
  1262 	}
 
  1268 
  1263 
  1269 /**
 
  1264 /**
 
  1270 @SYMTestCaseID      PBASE-T_FILE64BIT-0761
 
  1265 @SYMTestCaseID      PBASE-T_FILE64BIT-0761
 
  1313 	fileName.Append(KTestPath);
 
  1308 	fileName.Append(KTestPath);
 
  1314 	fileName.Append(_L("File4GBMinusOne.txt"));
 
  1309 	fileName.Append(_L("File4GBMinusOne.txt"));
 
  1315 	
  1310 	
  1316 	test.Start(_L("Test opening a file using RFile and RFile64 in file sharing mode\n"));
 
  1311 	test.Start(_L("Test opening a file using RFile and RFile64 in file sharing mode\n"));
 
  1317 	TInt r = file.Replace(TheFs,fileName,EFileShareAny|EFileWrite);
 
  1312 	TInt r = file.Replace(TheFs,fileName,EFileShareAny|EFileWrite);
 
  1318 	test_KErrNone(r);
 
  1313 	test(r == KErrNone);
 
  1319 	
  1314 	
  1320 	TBuf8<100> writeBuf;
 
  1315 	TBuf8<100> writeBuf;
 
  1321 	TBuf8<100> readBuf;
 
  1316 	TBuf8<100> readBuf;
 
  1322 	writeBuf.Zero();
 
  1317 	writeBuf.Zero();
 
  1323 	for(count = 0; count < 100; count++)
 
  1318 	for(count = 0; count < 100; count++)
 
  1325 		writeBuf.Append(count);
 
  1320 		writeBuf.Append(count);
 
  1326 		}
 
  1321 		}
 
  1327 		
  1322 		
  1328    	test.Next(_L("Write 100 bytes to the file\n"));
 
  1323    	test.Next(_L("Write 100 bytes to the file\n"));
 
  1329 	r = file.Write(0, writeBuf, 100);	
  1324 	r = file.Write(0, writeBuf, 100);	
  1330 	test_KErrNone(r);
 
  1325 	test(r == KErrNone);
 
  1331 	
  1326 	
  1332 	test.Next(_L("Read 100 bytes from position 0"));
 
  1327 	test.Next(_L("Read 100 bytes from position 0"));
 
  1333 	r = file.Read(0, readBuf, 100); 
  1328 	r = file.Read(0, readBuf, 100); 
  1334 	test_KErrNone(r);
 
  1329 	test(r == KErrNone);
 
  1335 	
  1330 	
  1336 	test.Next(_L("Compare the read data to the written data"));
 
  1331 	test.Next(_L("Compare the read data to the written data"));
 
  1337 	test(readBuf == writeBuf);
 
  1332 	test(readBuf == writeBuf);
 
  1338 
  1333 
  1339 	
  1334 	
  1343 	test.Next(_L("Set the file size to 4GB-1\n"));
 
  1338 	test.Next(_L("Set the file size to 4GB-1\n"));
 
  1344 	TestRFile1.SetSize(K4GBMinusOne);
 
  1339 	TestRFile1.SetSize(K4GBMinusOne);
 
  1345 	
  1340 	
  1346 	test.Next(_L("Query the file size using Rfile::Size()\n"));
 
  1341 	test.Next(_L("Query the file size using Rfile::Size()\n"));
 
  1347 	r = file.Size(size);
 
  1342 	r = file.Size(size);
 
  1348 	test_Value(r, r == KErrTooBig);
 
  1343 	test (r == KErrTooBig);
 
  1349 	
  1344 	
  1350 	test.Next(_L("Seek to the file position using 2GB+5 using RFile::Seek()\n"));
 
  1345 	test.Next(_L("Seek to the file position using 2GB+5 using RFile::Seek()\n"));
 
  1351 	TUint seekPos1 = K2GB + 5;
 
  1346 	TUint seekPos1 = K2GB + 5;
 
  1352 	TInt seekPos  = (TInt)seekPos1;
 
  1347 	TInt seekPos  = (TInt)seekPos1;
 
  1353 	r = file.Seek(ESeekStart,seekPos);
 
  1348 	r = file.Seek(ESeekStart,seekPos);
 
  1354 	test_Value(r, r == KErrArgument);
 
  1349 	test(r == KErrArgument);
 
  1355 	
  1350 	
  1356 	test.Next(_L("Get the file size using RFile64::Size()\n"));
 
  1351 	test.Next(_L("Get the file size using RFile64::Size()\n"));
 
  1357 	TestRFile1.Size(size64);
 
  1352 	TestRFile1.Size(size64);
 
  1358 	
  1353 	
  1359 	test.Next(_L("Seek to the file position 4GB-10 using RFile64::Seek()\n"));
 
  1354 	test.Next(_L("Seek to the file position 4GB-10 using RFile64::Seek()\n"));
 
  1377 	TestRFile1.Close();
 
  1372 	TestRFile1.Close();
 
  1378 	file.Close();
 
  1373 	file.Close();
 
  1379 	
  1374 	
  1380 	test.Next(_L("Open the file using Rfile::Open()\n"));
 
  1375 	test.Next(_L("Open the file using Rfile::Open()\n"));
 
  1381 	r = file.Open(TheFs,fileName,EFileShareAny|EFileWrite);
 
  1376 	r = file.Open(TheFs,fileName,EFileShareAny|EFileWrite);
 
  1382 	test_Value(r, r == KErrTooBig);
 
  1377 	test(r == KErrTooBig);
 
  1383 	
  1378 	
  1384 	test.Next(_L("Open the file using Rfile64::Open() and close\n"));
 
  1379 	test.Next(_L("Open the file using Rfile64::Open() and close\n"));
 
  1385 	TestRFile1.Open(fileName,EFileShareAny|EFileWrite);
 
  1380 	TestRFile1.Open(fileName,EFileShareAny|EFileWrite);
 
  1386 	TestRFile1.Close();
 
  1381 	TestRFile1.Close();
 
  1387 	
  1382 	
  1388 	r = TheFs.Delete(fileName);
 
  1383 	r = TheFs.Delete(fileName);
 
  1389 	test_KErrNone(r);
 
  1384 	test(r == KErrNone);
 
  1390 	}
 
  1385 	}
 
  1391 
  1386 
  1392 /**
 
  1387 /**
 
  1393 @SYMTestCaseID      PBASE-T_FILE64BIT-0762
 
  1388 @SYMTestCaseID      PBASE-T_FILE64BIT-0762
 
  1394 @SYMTestPriority    High
 
  1389 @SYMTestPriority    High
 
  1428 	TFileName testDir;
 
  1423 	TFileName testDir;
 
  1429 	testDir.Append(gDriveToTest);
 
  1424 	testDir.Append(gDriveToTest);
 
  1430 	testDir.Append(KTestPath);
 
  1425 	testDir.Append(KTestPath);
 
  1431 	
  1426 	
  1432 	TInt r = TheFs.MkDir(testDir);
 
  1427 	TInt r = TheFs.MkDir(testDir);
 
  1433 	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 
  1428 	test(r == KErrNone || r == KErrAlreadyExists);
 
  1434 	
  1429 	
  1435 	TFileName fileName;
 
  1430 	TFileName fileName;
 
  1436 	TestRFile1.Temp(testDir, fileName, EFileWrite|EDeleteOnClose);
 
  1431 	TestRFile1.Temp(testDir, fileName, EFileWrite|EDeleteOnClose);
 
  1437 	
  1432 	
  1438 	test.Next(_L("Set the file size to 4GB-1\n"));
 
  1433 	test.Next(_L("Set the file size to 4GB-1\n"));
 
  1489 	
  1484 	
  1490 	TestRFile1.Close();
 
  1485 	TestRFile1.Close();
 
  1491 	
  1486 	
  1492 	test.Next(_L("Delete the temporary file\n"));
 
  1487 	test.Next(_L("Delete the temporary file\n"));
 
  1493 	r = TheFs.Delete(fileName);
 
  1488 	r = TheFs.Delete(fileName);
 
  1494 	test_Value(r, r == KErrNotFound);
 
  1489 	test(r == KErrNotFound);
 
  1495 	
  1490 	
  1496 	test.Next(_L("Create a temporary file using RFile64::Temp without EDeleteOnClose flag\n"));
 
  1491 	test.Next(_L("Create a temporary file using RFile64::Temp without EDeleteOnClose flag\n"));
 
  1497 	TestRFile1.Temp(testDir, fileName, EFileWrite);
 
  1492 	TestRFile1.Temp(testDir, fileName, EFileWrite);
 
  1498 	
  1493 	
  1499 	test.Next(_L("Close the file\n"));	
  1494 	test.Next(_L("Close the file\n"));	
  1500 	TestRFile1.Close();
 
  1495 	TestRFile1.Close();
 
  1501 	
  1496 	
  1502 	test.Next(_L("Delete the temporary the file\n"));	
  1497 	test.Next(_L("Delete the temporary the file\n"));	
  1503 	r = TheFs.Delete(fileName);
 
  1498 	r = TheFs.Delete(fileName);
 
  1504 	test_KErrNone(r);
 
  1499 	test(r == KErrNone);
 
  1505 	
  1500 	
  1506 	}
 
  1501 	}
 
  1507 
  1502 
  1508 /**
 
  1503 /**
 
  1509 @SYMTestCaseID      PBASE-T_FILE64BIT-0763
 
  1504 @SYMTestCaseID      PBASE-T_FILE64BIT-0763
 
  1628 	TestRFile1.Create(fileName,EFileWrite);
 
  1623 	TestRFile1.Create(fileName,EFileWrite);
 
  1629 	
  1624 	
  1630 	test.Next(_L("create a file with InvalidPath and fileName\n"));	
  1625 	test.Next(_L("create a file with InvalidPath and fileName\n"));	
  1631 	RFile64 file64;
 
  1626 	RFile64 file64;
 
  1632 	TInt r = file64.Create(TheFs, _L("C:\\InvalidPathName\\FileName"),EFileWrite);
 
  1627 	TInt r = file64.Create(TheFs, _L("C:\\InvalidPathName\\FileName"),EFileWrite);
 
  1633 	test_Value(r, r == KErrPathNotFound);
 
  1628 	test(r == KErrPathNotFound);
 
  1634 	
  1629 	
  1635 	r = TheFs.Delete(fileName);
 
  1630 	r = TheFs.Delete(fileName);
 
  1636 	test_KErrNone(r);
 
  1631 	test(r == KErrNone);
 
  1637 	}	
  1632 	}	
  1638 	
  1633 	
  1639 /**
 
  1634 /**
 
  1640 @SYMTestCaseID      PBASE-T_FILE64BIT-0764
 
  1635 @SYMTestCaseID      PBASE-T_FILE64BIT-0764
 
  1641 @SYMTestPriority    High
 
  1636 @SYMTestPriority    High
 
  1778 	TestRFile1.Close();
 
  1773 	TestRFile1.Close();
 
  1779 	
  1774 	
  1780 	test.Next(_L("Replace a file FileLargeOne.txt with invalid path\n"));	
  1775 	test.Next(_L("Replace a file FileLargeOne.txt with invalid path\n"));	
  1781 	RFile64 file64;
 
  1776 	RFile64 file64;
 
  1782 	TInt r = file64.Replace(TheFs,_L("C:\\InvalidPath\\FileLargeOne.Txt"),EFileWrite);
 
  1777 	TInt r = file64.Replace(TheFs,_L("C:\\InvalidPath\\FileLargeOne.Txt"),EFileWrite);
 
  1783 	test_Value(r, r == KErrPathNotFound);
 
  1778 	test (r == KErrPathNotFound);
 
  1784 	
  1779 	
  1785 	r = TheFs.Delete(fileName);
 
  1780 	r = TheFs.Delete(fileName);
 
  1786 	test_KErrNone(r);
 
  1781 	test(r == KErrNone);
 
  1787 	}
 
  1782 	}
 
  1788 
  1783 
  1789 /**
 
  1784 /**
 
  1790 @SYMTestCaseID      PBASE-T_FILE64BIT-0765
 
  1785 @SYMTestCaseID      PBASE-T_FILE64BIT-0765
 
  1791 @SYMTestPriority    High
 
  1786 @SYMTestPriority    High
 
  1873 	test(readBuffer == _L8("ABCDEFGHIJ"));
 
  1868 	test(readBuffer == _L8("ABCDEFGHIJ"));
 
  1874 	
  1869 	
  1875 	test.Next(_L("Close the file and delete\n"));
 
  1870 	test.Next(_L("Close the file and delete\n"));
 
  1876 	TestRFile1.Close();
 
  1871 	TestRFile1.Close();
 
  1877 	TInt r = TheFs.Delete(fileNameReplace);
 
  1872 	TInt r = TheFs.Delete(fileNameReplace);
 
  1878 	test_KErrNone(r);
 
  1873 	test(r == KErrNone);
 
  1879 	}
 
  1874 	}
 
  1880 
  1875 
  1881 /**
 
  1876 /**
 
  1882 @SYMTestCaseID      PBASE-T_FILE64BIT-0766
 
  1877 @SYMTestCaseID      PBASE-T_FILE64BIT-0766
 
  1883 @SYMTestPriority    High
 
  1878 @SYMTestPriority    High
 
  1904 	{
 
  1899 	{
 
  1905 	test.Next(_L("Tests for checking RFile64::AdoptFromClient()"));
 
  1900 	test.Next(_L("Tests for checking RFile64::AdoptFromClient()"));
 
  1906 
  1901 
  1907 	RProcess p;
 
  1902 	RProcess p;
 
  1908 	TInt r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
 
  1903 	TInt r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
 
  1909 	test_KErrNone(r);
 
  1904 	test(r == KErrNone);
 
  1910 	
  1905 	
  1911 	
  1906 	
  1912 	test.Next(_L("Connect to the File server \n"));
 
  1907 	test.Next(_L("Connect to the File server \n"));
 
  1913 	RFs fs;
 
  1908 	RFs fs;
 
  1914 	r = fs.Connect();
 
  1909 	r = fs.Connect();
 
  1915 	test_KErrNone(r);
 
  1910 	test(r == KErrNone);
 
  1916 
  1911 
  1917 	// Check the number of open file handles
 
  1912 	// Check the number of open file handles
 
  1918 	TInt resCount = fs.ResourceCount();
 
  1913 	TInt resCount = fs.ResourceCount();
 
  1919 	test(resCount == 0);
 
  1914 	test(resCount == 0);
 
  1920 
  1915 
  1921 	r = fs.ShareProtected();
 
  1916 	r = fs.ShareProtected();
 
  1922 	test_KErrNone(r);
 
  1917 	test(r == KErrNone);
 
  1923 
  1918 
  1924 	r = fs.CreatePrivatePath(gDrive);
 
  1919 	r = fs.CreatePrivatePath(gDrive);
 
  1925 	test_KErrNone(r);
 
  1920 	test(r == KErrNone);
 
  1926 	r = fs.SetSessionToPrivate(gDrive);
 
  1921 	r = fs.SetSessionToPrivate(gDrive);
 
  1927 	
  1922 	
  1928 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 
  1923 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 
  1929 	RFile64 file1;
 
  1924 	RFile64 file1;
 
  1930 	r = file1.Replace(fs,KClientFileName,EFileWrite);
 
  1925 	r = file1.Replace(fs,KClientFileName,EFileWrite);
 
  1931 	test_KErrNone(r);
 
  1926 	test(r == KErrNone);
 
  1932 	r = file1.SetSize(K4GB-1);
 
  1927 	r = file1.SetSize(K4GB-1);
 
  1933 	test_KErrNone(r);
 
  1928 	test(r == KErrNone);
 
  1934 	
  1929 	
  1935 	test.Next(_L("Write few bytes to the location 4GB-10, length = 9bytes\n"));
 
  1930 	test.Next(_L("Write few bytes to the location 4GB-10, length = 9bytes\n"));
 
  1936 	r = file1.Write(K4GB-10,KTestData3(),9);
 
  1931 	r = file1.Write(K4GB-10,KTestData3(),9);
 
  1937 	test_KErrNone(r);
 
  1932 	test(r == KErrNone);
 
  1938 	file1.Close();
 
  1933 	file1.Close();
 
  1939 
  1934 
  1940 	r = p.SetParameter(3, gDrive);
 
  1935 	r = p.SetParameter(3, gDrive);
 
  1941 	test_KErrNone(r);
 
  1936 	test(r == KErrNone);
 
  1942 	
  1937 	
  1943 	p.Resume();
 
  1938 	p.Resume();
 
  1944 	
  1939 	
  1945 	
  1940 	
  1946 	test.Next(_L("Transfer the file handle using TransferToServer() close the file\n"));
 
  1941 	test.Next(_L("Transfer the file handle using TransferToServer() close the file\n"));
 
  1948 	do
 
  1943 	do
 
  1949 		{
 
  1944 		{
 
  1950 		r = handsvr.Connect();
 
  1945 		r = handsvr.Connect();
 
  1951 		}
 
  1946 		}
 
  1952 	while(r == KErrNotFound);
 
  1947 	while(r == KErrNotFound);
 
  1953 	test_KErrNone(r);
 
  1948 	test(r == KErrNone);
 
  1954 
  1949 
  1955 	r = handsvr.SetTestDrive(gDrive);
 
  1950 	r = handsvr.SetTestDrive(gDrive);
 
  1956 	test_KErrNone(r);
 
  1951 	test(r == KErrNone);
 
  1957 
  1952 
  1958 	r = fs.SetSessionToPrivate(gDrive);
 
  1953 	r = fs.SetSessionToPrivate(gDrive);
 
  1959 	test_KErrNone(r);
 
  1954 	test(r == KErrNone);
 
  1960 
  1955 
  1961 	r = file1.Open(fs,KClientFileName,EFileRead);
 
  1956 	r = file1.Open(fs,KClientFileName,EFileRead);
 
  1962 	test_KErrNone(r);
 
  1957 	test(r == KErrNone);
 
  1963 	
  1958 	
  1964 	// pass the file handle to FHServer
 
  1959 	// pass the file handle to FHServer
 
  1965 	test.Next(_L("RFile::TransferToServer()"));
 
  1960 	test.Next(_L("RFile::TransferToServer()"));
 
  1966 
  1961 
  1967 	TIpcArgs ipcArgs;
 
  1962 	TIpcArgs ipcArgs;
 
  1968 	r = file1.TransferToServer(ipcArgs, 0, 1);
 
  1963 	r = file1.TransferToServer(ipcArgs, 0, 1);
 
  1969 	test_KErrNone(r);
 
  1964 	test(r == KErrNone);
 
  1970 	
  1965 	
  1971 	test.Next(_L("Adopt the already open file from a client using RFile64::AdoptFromClient()\n"));
 
  1966 	test.Next(_L("Adopt the already open file from a client using RFile64::AdoptFromClient()\n"));
 
  1972 	r = handsvr.PassFileHandleProcessLargeFileClient(ipcArgs);
 
  1967 	r = handsvr.PassFileHandleProcessLargeFileClient(ipcArgs);
 
  1973 	test_KErrNone(r);
 
  1968 	test(r == KErrNone);
 
  1974 
  1969 
  1975 	// verify that the original file handle's position is unchanged
 
  1970 	// verify that the original file handle's position is unchanged
 
  1976 	TInt64 pos = 0;
 
  1971 	TInt64 pos = 0;
 
  1977 	r = file1.Seek(ESeekCurrent, pos);
 
  1972 	r = file1.Seek(ESeekCurrent, pos);
 
  1978 	test_KErrNone(r);
 
  1973 	test(r == KErrNone);
 
  1979 	test(pos == 0);
 
  1974 	test(pos == 0);
 
  1980 	// make sure we can still use it
 
  1975 	// make sure we can still use it
 
  1981 
  1976 
  1982 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));
 
  1977 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));
 
  1983 	TBuf8<9> rbuf;
 
  1978 	TBuf8<9> rbuf;
 
  1984 	r = file1.Read(K4GB-10,rbuf);
 
  1979 	r = file1.Read(K4GB-10,rbuf);
 
  1985 	test_KErrNone(r);
 
  1980 	test(r == KErrNone);
 
  1986 	test (rbuf == KTestData3);
 
  1981 	test (rbuf == KTestData3);
 
  1987 
  1982 
  1988 	// Close the file
 
  1983 	// Close the file
 
  1989 	file1.Close();	
  1984 	file1.Close();	
  1990 	handsvr.Exit();
 
  1985 	handsvr.Exit();
 
  1991 	handsvr.Close();
 
  1986 	handsvr.Close();
 
  1992 	r = fs.MkDir(_L("C:\\mdir"));
 
  1987 	r = fs.MkDir(_L("C:\\mdir"));
 
  1993 	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 
  1988 	test(r == KErrNone || r == KErrAlreadyExists);
 
  1994 		
  1989 		
  1995 	// Check the number of open file handles
 
  1990 	// Check the number of open file handles
 
  1996 	resCount = fs.ResourceCount();
 
  1991 	resCount = fs.ResourceCount();
 
  1997 	test(resCount == 0);
 
  1992 	test(resCount == 0);
 
  1998 
  1993 
  1999 	r = fs.Delete(KClientFileName);
 
  1994 	r = fs.Delete(KClientFileName);
 
  2000 	test_KErrNone(r);
 
  1995 	test(r == KErrNone);
 
  2001 	fs.Close();
 
  1996 	fs.Close();
 
  2002 	}
 
  1997 	}
 
  2003 
  1998 
  2004 /**
 
  1999 /**
 
  2005 @SYMTestCaseID      PBASE-T_FILE64BIT-0767
 
  2000 @SYMTestCaseID      PBASE-T_FILE64BIT-0767
 
  2034 	test.Next(_L("Tests for checking RFile64::AdoptFromCreator()"));
 
  2029 	test.Next(_L("Tests for checking RFile64::AdoptFromCreator()"));
 
  2035 	//create test server
 
  2030 	//create test server
 
  2036 	test.Next(_L("Create a process named FHServer64Bit.exe\n"));
 
  2031 	test.Next(_L("Create a process named FHServer64Bit.exe\n"));
 
  2037 	RProcess p;
 
  2032 	RProcess p;
 
  2038 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
 
  2033 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
 
  2039 	test_KErrNone(r);
 
  2034 	test(r == KErrNone);
 
  2040 		
  2035 		
  2041 	test.Next(_L("Connect to the file server\n"));
 
  2036 	test.Next(_L("Connect to the file server\n"));
 
  2042 	RFs fs;
 
  2037 	RFs fs;
 
  2043 	r = fs.Connect();
 
  2038 	r = fs.Connect();
 
  2044 	test_KErrNone(r);
 
  2039 	test(r == KErrNone);
 
  2045 
  2040 
  2046 	// Check the number of open file handles
 
  2041 	// Check the number of open file handles
 
  2047 	TInt resCount = fs.ResourceCount();
 
  2042 	TInt resCount = fs.ResourceCount();
 
  2048 	test(resCount == 0);
 
  2043 	test(resCount == 0);
 
  2049 
  2044 
  2050 	r = fs.ShareProtected();
 
  2045 	r = fs.ShareProtected();
 
  2051 	test_KErrNone(r);
 
  2046 	test(r == KErrNone);
 
  2052 
  2047 
  2053 	r = fs.CreatePrivatePath(gDrive);
 
  2048 	r = fs.CreatePrivatePath(gDrive);
 
  2054 	test_KErrNone(r);
 
  2049 	test(r == KErrNone);
 
  2055 	r = fs.SetSessionToPrivate(gDrive);
 
  2050 	r = fs.SetSessionToPrivate(gDrive);
 
  2056 	
  2051 	
  2057 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 
  2052 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 
  2058 	RFile64 file1;
 
  2053 	RFile64 file1;
 
  2059 	r = file1.Replace(fs,KClientFileName,EFileWrite);
 
  2054 	r = file1.Replace(fs,KClientFileName,EFileWrite);
 
  2060 	test_KErrNone(r);
 
  2055 	test(r == KErrNone);
 
  2061 	r = file1.SetSize(K4GB-1);
 
  2056 	r = file1.SetSize(K4GB-1);
 
  2062 	test_KErrNone(r);
 
  2057 	test(r == KErrNone);
 
  2063 	
  2058 	
  2064 	test.Next(_L("Write few bytes to the location 4GB-10, length = 3bytes\n"));
 
  2059 	test.Next(_L("Write few bytes to the location 4GB-10, length = 3bytes\n"));
 
  2065 	r = file1.Write(K4GB-10,KTestData2(),3);
 
  2060 	r = file1.Write(K4GB-10,KTestData2(),3);
 
  2066 	test_KErrNone(r);
 
  2061 	test(r == KErrNone);
 
  2067 	file1.Close();
 
  2062 	file1.Close();
 
  2068 
  2063 
  2069 	r = file1.Open(fs, KClientFileName, EFileWrite);
 
  2064 	r = file1.Open(fs, KClientFileName, EFileWrite);
 
  2070 
  2065 
  2071 	test_KErrNone(r);
 
  2066 	test(r == KErrNone);
 
  2072 	
  2067 	
  2073 	// NB slot 0 is reserved for the command line
 
  2068 	// NB slot 0 is reserved for the command line
 
  2074 
  2069 
  2075 	test.Next(_L("Transfer the file handle using TransferToProcess() close the file"));
 
  2070 	test.Next(_L("Transfer the file handle using TransferToProcess() close the file"));
 
  2076 
  2071 
  2077 	r = file1.TransferToProcess(p, 1, 2);
 
  2072 	r = file1.TransferToProcess(p, 1, 2);
 
  2078 
  2073 
  2079 	r = p.SetParameter(3, gDrive);
 
  2074 	r = p.SetParameter(3, gDrive);
 
  2080 	test_KErrNone(r);
 
  2075 	test(r == KErrNone);
 
  2081 
  2076 
  2082 	r = fs.SetSessionToPrivate(gDrive);
 
  2077 	r = fs.SetSessionToPrivate(gDrive);
 
  2083 	test_KErrNone(r);
 
  2078 	test(r == KErrNone);
 
  2084 
  2079 
  2085 	// make sure we can still read from the file
 
  2080 	// make sure we can still read from the file
 
  2086 	TBuf8<3> rbuf;
 
  2081 	TBuf8<3> rbuf;
 
  2087 	r = file1.Read(K4GB-10,rbuf,3);
 
  2082 	r = file1.Read(K4GB-10,rbuf,3);
 
  2088 	test_KErrNone(r);
 
  2083 	test(r == KErrNone);
 
  2089 	r = rbuf.CompareF(KTestData2());
 
  2084 	r = rbuf.CompareF(KTestData2());
 
  2090 	test_KErrNone(r);
 
  2085 	test(r == KErrNone);
 
  2091 	file1.Close();
 
  2086 	file1.Close();
 
  2092 
  2087 
  2093 	r = fs.MkDir(_L("C:\\mdir"));
 
  2088 	r = fs.MkDir(_L("C:\\mdir"));
 
  2094 	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 
  2089 	test(r == KErrNone || r == KErrAlreadyExists);
 
  2095 	
  2090 	
  2096 	// Check the number of open file handles - 
  2091 	// Check the number of open file handles - 
  2097 	// should be 1 (the one duplicated for the other process)
 
  2092 	// should be 1 (the one duplicated for the other process)
 
  2098 	resCount = fs.ResourceCount();
 
  2093 	resCount = fs.ResourceCount();
 
  2099 	test(resCount == 1);
 
  2094 	test(resCount == 1);
 
  2109 	do
 
  2104 	do
 
  2110 		{
 
  2105 		{
 
  2111 		r = handsvr.Connect();
 
  2106 		r = handsvr.Connect();
 
  2112 		}
 
  2107 		}
 
  2113 	while(r == KErrNotFound);
 
  2108 	while(r == KErrNotFound);
 
  2114 	test_KErrNone(r);
 
  2109 	test(r == KErrNone);
 
  2115 	r = handsvr.SetTestDrive(gDrive);
 
  2110 	r = handsvr.SetTestDrive(gDrive);
 
  2116 	test_KErrNone(r);
 
  2111 	test(r == KErrNone);
 
  2117 
  2112 
  2118 	// wait for server to read the file
 
  2113 	// wait for server to read the file
 
  2119 	r = handsvr.PassFileHandleProcessLargeFileCreator();
 
  2114 	r = handsvr.PassFileHandleProcessLargeFileCreator();
 
  2120 	test_KErrNone(r);
 
  2115 	test (r == KErrNone);
 
  2121 	
  2116 	
  2122 	
  2117 	
  2123 	// cleanup	
  2118 	// cleanup	
  2124 	handsvr.Exit();
 
  2119 	handsvr.Exit();
 
  2125 	handsvr.Close();
 
  2120 	handsvr.Close();
 
  2154 	TInt r;
 
  2149 	TInt r;
 
  2155 	
  2150 	
  2156 	test.Next(_L("Connect to the file server\n"));
 
  2151 	test.Next(_L("Connect to the file server\n"));
 
  2157 	RFs fs;
 
  2152 	RFs fs;
 
  2158 	r = fs.Connect();
 
  2153 	r = fs.Connect();
 
  2159 	test_KErrNone(r);
 
  2154 	test(r == KErrNone);
 
  2160 
  2155 
  2161 	// Check the number of open file handles
 
  2156 	// Check the number of open file handles
 
  2162 	TInt resCount = fs.ResourceCount();
 
  2157 	TInt resCount = fs.ResourceCount();
 
  2163 	test(resCount == 0);
 
  2158 	test(resCount == 0);
 
  2164 
  2159 
  2165 	r = fs.ShareProtected();
 
  2160 	r = fs.ShareProtected();
 
  2166 	test_KErrNone(r);
 
  2161 	test(r == KErrNone);
 
  2167 
  2162 
  2168 	r = fs.CreatePrivatePath(gDrive);
 
  2163 	r = fs.CreatePrivatePath(gDrive);
 
  2169 	test_KErrNone(r);
 
  2164 	test(r == KErrNone);
 
  2170 	r = fs.SetSessionToPrivate(gDrive);
 
  2165 	r = fs.SetSessionToPrivate(gDrive);
 
  2171 	
  2166 	
  2172 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 
  2167 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 
  2173 	RFile64 file1;
 
  2168 	RFile64 file1;
 
  2174 	r = file1.Replace(fs,KClientFileName,EFileWrite);
 
  2169 	r = file1.Replace(fs,KClientFileName,EFileWrite);
 
  2175 	test_KErrNone(r);
 
  2170 	test(r == KErrNone);
 
  2176 	r = file1.SetSize(K4GB-1);
 
  2171 	r = file1.SetSize(K4GB-1);
 
  2177 	test_KErrNone(r);
 
  2172 	test(r == KErrNone);
 
  2178 	
  2173 	
  2179 	
  2174 	
  2180 	r = file1.Write(K4GB-10,KTestData3(),9);
 
  2175 	r = file1.Write(K4GB-10,KTestData3(),9);
 
  2181 	test_KErrNone(r);
 
  2176 	test(r == KErrNone);
 
  2182 		
  2177 		
  2183 	file1.Close();
 
  2178 	file1.Close();
 
  2184 	r = fs.Delete(KClientFileName);
 
  2179 	r = fs.Delete(KClientFileName);
 
  2185 	test_KErrNone(r);
 
  2180 	test(r == KErrNone);
 
  2186 	
  2181 	
  2187 	RProcess p;
 
  2182 	RProcess p;
 
  2188 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
 
  2183 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
 
  2189 	test_KErrNone(r);
 
  2184 	test(r == KErrNone);
 
  2190 	// Request an open file (write mode) from the server
 
  2185 	// Request an open file (write mode) from the server
 
  2191 	// using RFile64::AdoptFromServer()
 
  2186 	// using RFile64::AdoptFromServer()
 
  2192 	
  2187 	
  2193 	test.Next(_L("Adopt an already open file from a server using RFile64::AdoptFromServer()\n"));
 
  2188 	test.Next(_L("Adopt an already open file from a server using RFile64::AdoptFromServer()\n"));
 
  2194 	p.Resume();
 
  2189 	p.Resume();
 
  2196 	do
 
  2191 	do
 
  2197 		{
 
  2192 		{
 
  2198 		r = handsvr.Connect();
 
  2193 		r = handsvr.Connect();
 
  2199 		}
 
  2194 		}
 
  2200 	while(r == KErrNotFound);
 
  2195 	while(r == KErrNotFound);
 
  2201 	test_KErrNone(r);
 
  2196 	test(r == KErrNone);
 
  2202 
  2197 
  2203 	r = handsvr.SetTestDrive(gDrive);
 
  2198 	r = handsvr.SetTestDrive(gDrive);
 
  2204 	test_KErrNone(r);
 
  2199 	test(r == KErrNone);
 
  2205 
  2200 
  2206 	TInt ssh;
 
  2201 	TInt ssh;
 
  2207 	TInt fsh = handsvr.GetFileHandleLargeFile2(ssh, EFileWrite);
 
  2202 	TInt fsh = handsvr.GetFileHandleLargeFile2(ssh, EFileWrite);
 
  2208 	test (fsh >= 0);
 
  2203 	test (fsh >= 0);
 
  2209 
  2204 
  2218 	// adopt the file handle from FHServer
 
  2213 	// adopt the file handle from FHServer
 
  2219 	test.Next(_L("RFile64::AdoptFromServer()"));
 
  2214 	test.Next(_L("RFile64::AdoptFromServer()"));
 
  2220 
  2215 
  2221 	RFile64 file;
 
  2216 	RFile64 file;
 
  2222 	r = file.AdoptFromServer(fsh, ssh);
 
  2217 	r = file.AdoptFromServer(fsh, ssh);
 
  2223 	test_KErrNone(r);
 
  2218 	test(r == KErrNone);
 
  2224 
  2219 
  2225 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));
 
  2220 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));
 
  2226 	TBuf8<9> rbuf;
 
  2221 	TBuf8<9> rbuf;
 
  2227 	r = file.Read(K4GB-10,rbuf);
 
  2222 	r = file.Read(K4GB-10,rbuf);
 
  2228 	test_KErrNone(r);
 
  2223 	test(r == KErrNone);
 
  2229 	// server should write KTestData1 ("Server!!!") to file
 
  2224 	// server should write KTestData1 ("Server!!!") to file
 
  2230 	test (rbuf == KTestData4);
 
  2225 	test (rbuf == KTestData4);
 
  2231 
  2226 
  2232 	TFileName fileName;
 
  2227 	TFileName fileName;
 
  2233 	r = file.FullName(fileName);
 
  2228 	r = file.FullName(fileName);
 
  2234 	test_KErrNone(r);
 
  2229 	test(r == KErrNone);
 
  2235 	
  2230 	
  2236 	file.Close();
 
  2231 	file.Close();
 
  2237 	//cleanup
 
  2232 	//cleanup
 
  2238 	r = fs.Delete(fileName);
 
  2233 	r = fs.Delete(fileName);
 
  2239 	test_KErrNone(r);
 
  2234 	test(r == KErrNone);
 
  2240 		
  2235 		
  2241 	TFileName sessionPath;
 
  2236 	TFileName sessionPath;
 
  2242 	r = fs.SessionPath(sessionPath);
 
  2237 	r = fs.SessionPath(sessionPath);
 
  2243 	test_KErrNone(r);
 
  2238 	test(r == KErrNone);
 
  2244 	
  2239 	
  2245 	r = fs.RmDir(sessionPath);
 
  2240 	r = fs.RmDir(sessionPath);
 
  2246 	test_KErrNone(r);
 
  2241 	test(r == KErrNone);
 
  2247 	
  2242 	
  2248 	fs.Close();
 
  2243 	fs.Close();
 
  2249 	
  2244 	
  2250 	}
 
  2245 	}
 
  2251 
  2246 
  2274 	TUint 			pos;
 
  2269 	TUint 			pos;
 
  2275 	TBuf8<KBufSize> readBuf1;
 
  2270 	TBuf8<KBufSize> readBuf1;
 
  2276 	TBuf8<KBufSize> readBuf2;
 
  2271 	TBuf8<KBufSize> readBuf2;
 
  2277 	TUint i;
 
  2272 	TUint i;
 
  2278 	TInt r = GenerateBigFileContents();
 
  2273 	TInt r = GenerateBigFileContents();
 
  2279 	test_KErrNone(r);
 
  2274 	test(r == KErrNone);
 
  2280 	
  2275 	
  2281 	test.Next(_L("Open & Read Synchronously Large File From Diff Offset:"));
 
  2276 	test.Next(_L("Open & Read Synchronously Large File From Diff Offset:"));
 
  2282 
  2277 
  2283 	TFileName fileName;
 
  2278 	TFileName fileName;
 
  2284 	fileName.Append(gDriveToTest);
 
  2279 	fileName.Append(gDriveToTest);
 
  2904 	TestRFile1.Read(pos, readBuf, 0, status7);
 
  2899 	TestRFile1.Read(pos, readBuf, 0, status7);
 
  2905 
  2900 
  2906 	TestRFile1.Close();
 
  2901 	TestRFile1.Close();
 
  2907 	
  2902 	
  2908 	TInt r = TheFs.Delete(fileName);
 
  2903 	TInt r = TheFs.Delete(fileName);
 
  2909 	test_KErrNone(r);
 
  2904 	test(r == KErrNone);
 
  2910 	}	
  2905 	}	
  2911 
  2906 
  2912 /**
 
  2907 /**
 
  2913 @SYMTestCaseID      PBASE-T_FILE64BIT-0773
 
  2908 @SYMTestCaseID      PBASE-T_FILE64BIT-0773
 
  2914 @SYMTestPriority    High
 
  2909 @SYMTestPriority    High
 
  3041 		test(readBuffer256.Length() == 0);
 
  3036 		test(readBuffer256.Length() == 0);
 
  3042 		}
 
  3037 		}
 
  3043 	TestRFile1.Close();
 
  3038 	TestRFile1.Close();
 
  3044 	
  3039 	
  3045 	TInt r = TheFs.Delete(fileName);
 
  3040 	TInt r = TheFs.Delete(fileName);
 
  3046 	test_KErrNone(r);
 
  3041 	test(r == KErrNone);
 
  3047 	}
 
  3042 	}
 
  3048 
  3043 
  3049 /**
 
  3044 /**
 
  3050 @SYMTestCaseID      PBASE-T_FILE64BIT-0774
 
  3045 @SYMTestCaseID      PBASE-T_FILE64BIT-0774
 
  3051 @SYMTestPriority    High
 
  3046 @SYMTestPriority    High
 
  3180 		test(readBuf256.Length() == 0);
 
  3175 		test(readBuf256.Length() == 0);
 
  3181 		}
 
  3176 		}
 
  3182 	TestRFile1.Close();
 
  3177 	TestRFile1.Close();
 
  3183 	
  3178 	
  3184 	TInt r = TheFs.Delete(fileName);
 
  3179 	TInt r = TheFs.Delete(fileName);
 
  3185 	test_KErrNone(r);
 
  3180 	test(r == KErrNone);
 
  3186 	}
 
  3181 	}
 
  3187 
  3182 
  3188 /**
 
  3183 /**
 
  3189 @SYMTestCaseID      PBASE-T_FILE64BIT-0775
 
  3184 @SYMTestCaseID      PBASE-T_FILE64BIT-0775
 
  3190 @SYMTestPriority    High
 
  3185 @SYMTestPriority    High
 
  3345 		}
 
  3340 		}
 
  3346 	TestRFile1.Write(0,wrBuf256,-1);
 
  3341 	TestRFile1.Write(0,wrBuf256,-1);
 
  3347 	TestRFile1.Close();
 
  3342 	TestRFile1.Close();
 
  3348 	
  3343 	
  3349 	TInt r = TheFs.Delete(fileName);
 
  3344 	TInt r = TheFs.Delete(fileName);
 
  3350 	test_KErrNone(r);
 
  3345 	test(r == KErrNone);
 
  3351 	}
 
  3346 	}
 
  3352 		
  3347 		
  3353 /**
 
  3348 /**
 
  3354 @SYMTestCaseID      PBASE-T_FILE64BIT-0776
 
  3349 @SYMTestCaseID      PBASE-T_FILE64BIT-0776
 
  3355 @SYMTestPriority    High
 
  3350 @SYMTestPriority    High
 
  3525 	TRequestStatus status7 = KRequestPending;
 
  3520 	TRequestStatus status7 = KRequestPending;
 
  3526 	TestRFile1.Write(0,wrBuf256,-1,status7);
 
  3521 	TestRFile1.Write(0,wrBuf256,-1,status7);
 
  3527 	TestRFile1.Close();
 
  3522 	TestRFile1.Close();
 
  3528 	
  3523 	
  3529 	TInt r = TheFs.Delete(fileName);
 
  3524 	TInt r = TheFs.Delete(fileName);
 
  3530 	test_KErrNone(r);
 
  3525 	test(r == KErrNone);
 
  3531 	}
 
  3526 	}
 
  3532 			
  3527 			
  3533 /**
 
  3528 /**
 
  3534 @SYMTestCaseID      PBASE-T_FILE64BIT-0777
 
  3529 @SYMTestCaseID      PBASE-T_FILE64BIT-0777
 
  3535 @SYMTestPriority    High
 
  3530 @SYMTestPriority    High
 
  3597 	}
 
  3592 	}
 
  3598 
  3593 
  3599 	TestRFile1.Close();
 
  3594 	TestRFile1.Close();
 
  3600 	
  3595 	
  3601 	TInt r = TheFs.Delete(fileName);
 
  3596 	TInt r = TheFs.Delete(fileName);
 
  3602 	test_KErrNone(r);
 
  3597 	test(r == KErrNone);
 
  3603 	}
 
  3598 	}
 
  3604 
  3599 
  3605 
  3600 
  3606 /**
 
  3601 /**
 
  3607 @SYMTestCaseID      PBASE-T_FILE64BIT-0778
 
  3602 @SYMTestCaseID      PBASE-T_FILE64BIT-0778
 
  3706 	TestRFile2.UnLock(K4GB, 10);	
  3701 	TestRFile2.UnLock(K4GB, 10);	
  3707 	    }
 
  3702 	    }
 
  3708 
  3703 
  3709     TestRFile2.Close();
 
  3704     TestRFile2.Close();
 
  3710 	TInt r = TheFs.Delete(fileName);
 
  3705 	TInt r = TheFs.Delete(fileName);
 
  3711 	test_KErrNone(r);
 
  3706 	test(r == KErrNone);
 
  3712 	}
 
  3707 	}
 
  3713 
  3708 
  3714 /**
 
  3709 /**
 
  3715 @SYMTestCaseID      PBASE-T_FILE64BIT-0779
 
  3710 @SYMTestCaseID      PBASE-T_FILE64BIT-0779
 
  3716 @SYMTestPriority    High
 
  3711 @SYMTestPriority    High
 
  3800 	test(seekPos == 512);
 
  3795 	test(seekPos == 512);
 
  3801 
  3796 
  3802 	TestRFile1.Close();
 
  3797 	TestRFile1.Close();
 
  3803 	
  3798 	
  3804 	TInt r = TheFs.Delete(fileName);
 
  3799 	TInt r = TheFs.Delete(fileName);
 
  3805 	test_KErrNone(r);
 
  3800 	test(r == KErrNone);
 
  3806 	}
 
  3801 	}
 
  3807 
  3802 
  3808 /**
 
  3803 /**
 
  3809 @SYMTestCaseID      PBASE-T_FILE64BIT-0780
 
  3804 @SYMTestCaseID      PBASE-T_FILE64BIT-0780
 
  3810 @SYMTestPriority    High
 
  3805 @SYMTestPriority    High
 
  3907 		
  3902 		
  3908 
  3903 
  3909 	TestRFile1.Close();
 
  3904 	TestRFile1.Close();
 
  3910 	
  3905 	
  3911 	TInt r = TheFs.Delete(fileName);
 
  3906 	TInt r = TheFs.Delete(fileName);
 
  3912 	test_KErrNone(r);
 
  3907 	test(r == KErrNone);
 
  3913 }
 
  3908 }
 
  3914 
  3909 
  3915 /**
 
  3910 /**
 
  3916 @SYMTestCaseID      PBASE-T_FILE64BIT-0781
 
  3911 @SYMTestCaseID      PBASE-T_FILE64BIT-0781
 
  3917 @SYMTestPriority    High
 
  3912 @SYMTestPriority    High
 
  4014 	TestRFile1.Read(K4GBMinusTen,testData6,9);
 
  4009 	TestRFile1.Read(K4GBMinusTen,testData6,9);
 
  4015 	test(testData6 == _L8("IJKLMnOPx"));
 
  4010 	test(testData6 == _L8("IJKLMnOPx"));
 
  4016 	TestRFile1.Close();
 
  4011 	TestRFile1.Close();
 
  4017 	
  4012 	
  4018 	TInt r = TheFs.Delete(fileName);
 
  4013 	TInt r = TheFs.Delete(fileName);
 
  4019 	test_KErrNone(r);
 
  4014 	test(r == KErrNone);
 
  4020 	}
 
  4015 	}
 
  4021 
  4016 
  4022 /**
 
  4017 /**
 
  4023 @SYMTestCaseID      PBASE-T_FILE64BIT-0782
 
  4018 @SYMTestCaseID      PBASE-T_FILE64BIT-0782
 
  4024 @SYMTestPriority    High
 
  4019 @SYMTestPriority    High
 
  4051 	fileName.Append(gDriveToTest);
 
  4046 	fileName.Append(gDriveToTest);
 
  4052 	fileName.Append(KTestPath);
 
  4047 	fileName.Append(KTestPath);
 
  4053 	fileName.Append(_L("File4GBMinusOne.txt"));
 
  4048 	fileName.Append(_L("File4GBMinusOne.txt"));
 
  4054 	
  4049 	
  4055 	TInt r = file.Replace(TheFs,fileName,EFileWrite);
 
  4050 	TInt r = file.Replace(TheFs,fileName,EFileWrite);
 
  4056 	test_KErrNone(r);
 
  4051 	test(r == KErrNone);
 
  4057 	r = file.SetSize(K4GBMinusOne);
 
  4052 	r = file.SetSize(K4GBMinusOne);
 
  4058 	test_KErrNone(r);
 
  4053 	test(r == KErrNone);
 
  4059 	file.Close();
 
  4054 	file.Close();
 
  4060 	
  4055 	
  4061 	test.Next(_L("Read from a big file using RFs::ReadFileSection() from position 3GB-1,52byte lengths of data\n"));
 
  4056 	test.Next(_L("Read from a big file using RFs::ReadFileSection() from position 3GB-1,52byte lengths of data\n"));
 
  4062 	TestRFs.ReadFileSection(fileName,K3GBMinusOne,testDes,52);
 
  4057 	TestRFs.ReadFileSection(fileName,K3GBMinusOne,testDes,52);
 
  4063 
  4058 
  4084 		{
 
  4079 		{
 
  4085 		TestRFs.ReadFileSection(fileName,K4GB,readBuf,52);
 
  4080 		TestRFs.ReadFileSection(fileName,K4GB,readBuf,52);
 
  4086 		}
 
  4081 		}
 
  4087 		
  4082 		
  4088 	r = TheFs.Delete(fileName);
 
  4083 	r = TheFs.Delete(fileName);
 
  4089 	test_KErrNone(r);
 
  4084 	test(r == KErrNone);
 
  4090 	}
 
  4085 	}
 
  4091 	
  4086 	
  4092 /**
 
  4087 /**
 
  4093 @SYMTestCaseID      PBASE-T_FILE64BIT-0783
 
  4088 @SYMTestCaseID      PBASE-T_FILE64BIT-0783
 
  4094 @SYMTestPriority    High
 
  4089 @SYMTestPriority    High
 
  4148 	TestRFile1.Close();
 
  4143 	TestRFile1.Close();
 
  4149 		
  4144 		
  4150 	test.Next(_L("Get the directory listing, sort by size\n"));
 
  4145 	test.Next(_L("Get the directory listing, sort by size\n"));
 
  4151 	RDir dir;
 
  4146 	RDir dir;
 
  4152 	TInt r = dir.Open(TheFs, dirName, KEntryAttNormal);
 
  4147 	TInt r = dir.Open(TheFs, dirName, KEntryAttNormal);
 
  4153 	test_KErrNone(r);
 
  4148 	test (r == KErrNone);
 
  4154 	
  4149 	
  4155 	TEntryArray entryArray;
 
  4150 	TEntryArray entryArray;
 
  4156 	r = dir.Read(entryArray);
 
  4151 	r = dir.Read(entryArray);
 
  4157 	test_Value(r, r == KErrEof);
 
  4152 	test (r == KErrEof);
 
  4158 
  4153 
  4159 	test.Next(_L("Check the files count in the directory. Number of files in a directory is 4\n"));
 
  4154 	test.Next(_L("Check the files count in the directory. Number of files in a directory is 4\n"));
 
  4160 	test(entryArray.Count() == gFilesInDirectory);
 
  4155 	test(entryArray.Count() == gFilesInDirectory);
 
  4161 	
  4156 	
  4162 	test.Next(_L("Get the entry list & Check the files are listed in order of file sizes\n"));
 
  4157 	test.Next(_L("Get the entry list & Check the files are listed in order of file sizes\n"));
 
  4300 	dirName.Append(KTestPath);
 
  4295 	dirName.Append(KTestPath);
 
  4301 	
  4296 	
  4302 	test.Next(_L("Open the directory containing large file, using RDir open()\n"));
 
  4297 	test.Next(_L("Open the directory containing large file, using RDir open()\n"));
 
  4303 	RDir dir;
 
  4298 	RDir dir;
 
  4304 	TInt r = dir.Open(TheFs, dirName, KEntryAttNormal);
 
  4299 	TInt r = dir.Open(TheFs, dirName, KEntryAttNormal);
 
  4305 	test_KErrNone(r);
 
  4300 	test (r == KErrNone);
 
  4306 	
  4301 	
  4307 	test.Next(_L("Read the directory entry using TEntryArray as parameter\n"));
 
  4302 	test.Next(_L("Read the directory entry using TEntryArray as parameter\n"));
 
  4308 	TEntryArray entryArray;
 
  4303 	TEntryArray entryArray;
 
  4309 	r = dir.Read(entryArray);
 
  4304 	r = dir.Read(entryArray);
 
  4310 	test_Value(r, r == KErrEof);
 
  4305 	test (r == KErrEof);
 
  4311 	
  4306 	
  4312 	test.Next(_L("Check the count\n"));
 
  4307 	test.Next(_L("Check the count\n"));
 
  4313 	test(entryArray.Count() == gFilesInDirectory);
 
  4308 	test(entryArray.Count() == gFilesInDirectory);
 
  4314 	
  4309 	
  4315 	test.Next(_L("Close using RDir\n"));
 
  4310 	test.Next(_L("Close using RDir\n"));
 
  4344 	TFileName testDir0;
 
  4339 	TFileName testDir0;
 
  4345 	testDir0.Append(gDriveToTest);
 
  4340 	testDir0.Append(gDriveToTest);
 
  4346 	testDir0.Append(_L("F32-TEST"));
 
  4341 	testDir0.Append(_L("F32-TEST"));
 
  4347 	
  4342 	
  4348 	TInt r = TheFs.MkDir(testDir0);
 
  4343 	TInt r = TheFs.MkDir(testDir0);
 
  4349 	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 
  4344 	test(r == KErrNone || r == KErrAlreadyExists);
 
  4350 	
  4345 	
  4351 	test.Next(_L("Sort with number of entries =0\n"));
 
  4346 	test.Next(_L("Sort with number of entries =0\n"));
 
  4352 	TestRFs.GetDir(testDir0, KEntryAttMaskSupported, ESortBySize, anEntryList);
 
  4347 	TestRFs.GetDir(testDir0, KEntryAttMaskSupported, ESortBySize, anEntryList);
 
  4353 	test(anEntryList->Count() == 0);
 
  4348 	test(anEntryList->Count() == 0);
 
  4354 	delete anEntryList;
 
  4349 	delete anEntryList;
 
  4471 	file3GB.Append(gDriveToTest);
 
  4466 	file3GB.Append(gDriveToTest);
 
  4472 	file3GB.Append(KTestPath);
 
  4467 	file3GB.Append(KTestPath);
 
  4473 	file3GB.Append(_L("File3GB.txt"));
 
  4468 	file3GB.Append(_L("File3GB.txt"));
 
  4474 	
  4469 	
  4475 	TInt r = TheFs.Delete(file4GBMinusOne);
 
  4470 	TInt r = TheFs.Delete(file4GBMinusOne);
 
  4476 	test_KErrNone(r);
 
  4471 	test(r == KErrNone);
 
  4477 	r = TheFs.Delete(file2GBMinusOne);
 
  4472 	r = TheFs.Delete(file2GBMinusOne);
 
  4478 	test_KErrNone(r);
 
  4473 	test(r == KErrNone);
 
  4479 	r = TheFs.Delete(file2GB);
 
  4474 	r = TheFs.Delete(file2GB);
 
  4480 	test_KErrNone(r);
 
  4475 	test(r == KErrNone);
 
  4481 	r = TheFs.Delete(file3GB);
 
  4476 	r = TheFs.Delete(file3GB);
 
  4482 	test_KErrNone(r);
 
  4477 	test(r == KErrNone);
 
  4483 	}
 
  4478 	}
 
  4484 	
  4479 	
  4485 /**
 
  4480 /**
 
  4486 @SYMTestCaseID      PBASE-T_FILE64BIT-0788
 
  4481 @SYMTestCaseID      PBASE-T_FILE64BIT-0788
 
  4487 @SYMTestPriority    High
 
  4482 @SYMTestPriority    High
 
  4524 	RFile64 file64;
 
  4519 	RFile64 file64;
 
  4525 	TInt64 sizeK3GB = K3GB;
 
  4520 	TInt64 sizeK3GB = K3GB;
 
  4526 	
  4521 	
  4527 	test.Next(_L("Open test file and get the file size using RFile64::Size() and set the file handle to TFileText object\n"));
 
  4522 	test.Next(_L("Open test file and get the file size using RFile64::Size() and set the file handle to TFileText object\n"));
 
  4528 	r = file64.Replace(TheFs,fileName,EFileRead|EFileWrite);
 
  4523 	r = file64.Replace(TheFs,fileName,EFileRead|EFileWrite);
 
  4529 	test_KErrNone(r);
 
  4524 	test(r == KErrNone);
 
  4530 	r = file64.SetSize(sizeK3GB);
 
  4525 	r = file64.SetSize(sizeK3GB);
 
  4531 	test_KErrNone(r);
 
  4526 	test(r == KErrNone);
 
  4532 	TFileText fileText;
 
  4527 	TFileText fileText;
 
  4533 	fileText.Set(file64);
 
  4528 	fileText.Set(file64);
 
  4534 	
  4529 	
  4535 	test.Next(_L("Seek to the file end using TFileText::Seek()\n"));
 
  4530 	test.Next(_L("Seek to the file end using TFileText::Seek()\n"));
 
  4536 	r = fileText.Seek(ESeekEnd);
 
  4531 	r = fileText.Seek(ESeekEnd);
 
  4537 	test_KErrNone(r);
 
  4532 	test(r == KErrNone);
 
  4538 	
  4533 	
  4539 	test.Next(_L("Get current file position using RFile64::Seek() and verify it is at file end.\n"));
 
  4534 	test.Next(_L("Get current file position using RFile64::Seek() and verify it is at file end.\n"));
 
  4540 	TInt64 pos = 0;
 
  4535 	TInt64 pos = 0;
 
  4541 	r = file64.Seek(ESeekCurrent, pos);
 
  4536 	r = file64.Seek(ESeekCurrent, pos);
 
  4542 	test_KErrNone(r);
 
  4537 	test(r == KErrNone);
 
  4543 	test(pos == sizeK3GB);
 
  4538 	test(pos == sizeK3GB);
 
  4544 	
  4539 	
  4545 	test.Next(_L("Write data to the file using RFile64::Write\n"));
 
  4540 	test.Next(_L("Write data to the file using RFile64::Write\n"));
 
  4546 	HBufC* record = HBufC::NewL(10);
 
  4541 	HBufC* record = HBufC::NewL(10);
 
  4547 	record->Des().SetLength(10);
 
  4542 	record->Des().SetLength(10);
 
  4548 	record->Des().Fill('A');
 
  4543 	record->Des().Fill('A');
 
  4549 	TPtrC8 bufPtr;
 
  4544 	TPtrC8 bufPtr;
 
  4550 	bufPtr.Set((TUint8*)record->Ptr(),record->Size()); // Size() returns length in bytes
 
  4545 	bufPtr.Set((TUint8*)record->Ptr(),record->Size()); // Size() returns length in bytes
 
  4551 	r = file64.Write(pos,bufPtr);
 
  4546 	r = file64.Write(pos,bufPtr);
 
  4552 	test_KErrNone(r);
 
  4547 	test(r == KErrNone);
 
  4553 	
  4548 	
  4554 	test.Next(_L("Read data using TFileText::Read\n"));
 
  4549 	test.Next(_L("Read data using TFileText::Read\n"));
 
  4555 	TBuf<20> fileTextReadBuf;
 
  4550 	TBuf<20> fileTextReadBuf;
 
  4556 	file64.Seek(ESeekStart,pos);//seek to the position where the data has been written
 
  4551 	file64.Seek(ESeekStart,pos);//seek to the position where the data has been written
 
  4557 	r = fileText.Read(fileTextReadBuf);
 
  4552 	r = fileText.Read(fileTextReadBuf);
 
  4558 	test(fileTextReadBuf == _L("AAAAAAAAAA"));
 
  4553 	test(fileTextReadBuf == _L("AAAAAAAAAA"));
 
  4559 	
  4554 	
  4560 	test.Next(_L("Seek to the file end using TFileText::Seek(ESeekEnd)\n"));
 
  4555 	test.Next(_L("Seek to the file end using TFileText::Seek(ESeekEnd)\n"));
 
  4561 	r = fileText.Seek(ESeekEnd);
 
  4556 	r = fileText.Seek(ESeekEnd);
 
  4562 	test_KErrNone(r);
 
  4557 	test(r == KErrNone);
 
  4563 	
  4558 	
  4564 	test.Next(_L("Write known data using TFileText::Write\n"));
 
  4559 	test.Next(_L("Write known data using TFileText::Write\n"));
 
  4565 	TBuf<20> fileTextWriteBuf(_L("AAAAAAAAAA"));
 
  4560 	TBuf<20> fileTextWriteBuf(_L("AAAAAAAAAA"));
 
  4566 	pos = 0;
 
  4561 	pos = 0;
 
  4567 	r = file64.Seek(ESeekCurrent,pos);
 
  4562 	r = file64.Seek(ESeekCurrent,pos);
 
  4568 	r = fileText.Write(fileTextWriteBuf);
 
  4563 	r = fileText.Write(fileTextWriteBuf);
 
  4569 	test_KErrNone(r);
 
  4564 	test(r == KErrNone);
 
  4570 	
  4565 	
  4571 	test.Next(_L("Read the data using RFile64::Read\n"));
 
  4566 	test.Next(_L("Read the data using RFile64::Read\n"));
 
  4572 	TBuf8<20> file64ReadBuf;
 
  4567 	TBuf8<20> file64ReadBuf;
 
  4573 	file64ReadBuf.Zero();
 
  4568 	file64ReadBuf.Zero();
 
  4574 	r = file64.Read(pos,file64ReadBuf);
 
  4569 	r = file64.Read(pos,file64ReadBuf);
 
  4575 	r = bufPtr.Compare(file64ReadBuf);
 
  4570 	r = bufPtr.Compare(file64ReadBuf);
 
  4576 	test_KErrNone(r);
 
  4571 	test (r == KErrNone);
 
  4577 	
  4572 	
  4578 	file64.Close();
 
  4573 	file64.Close();
 
  4579 	
  4574 	
  4580 	r = TheFs.Delete(fileName);
 
  4575 	r = TheFs.Delete(fileName);
 
  4581 	test_KErrNone(r);
 
  4576 	test(r == KErrNone);
 
  4582 	User::Free(record);
 
  4577 	User::Free(record);
 
  4583 	}
 
  4578 	}
 
  4584 
  4579 
  4585 
  4580 
  4586 /**
 
  4581 /**
 
  4669     
  4664     
  4670     TestRFile2.Close();
 
  4665     TestRFile2.Close();
 
  4671 	TestRFile1.Close();
 
  4666 	TestRFile1.Close();
 
  4672 	
  4667 	
  4673 	TInt r = TheFs.Delete(fileName);
 
  4668 	TInt r = TheFs.Delete(fileName);
 
  4674 	test_KErrNone(r);
 
  4669 	test(r == KErrNone);
 
  4675 	test.End();
 
  4670 	test.End();
 
  4676 	}
 
  4671 	}
 
  4677 
  4672 
  4678 /**
 
  4673 /**
 
  4679 @SYMTestCaseID      PBASE-T_FILE64BIT-0790
 
  4674 @SYMTestCaseID      PBASE-T_FILE64BIT-0790
 
  4749 	fileName1.Append(gDriveToTest);
 
  4744 	fileName1.Append(gDriveToTest);
 
  4750 	fileName1.Append(KTestPath);
 
  4745 	fileName1.Append(KTestPath);
 
  4751 	fileName1.Append(_L("File2GB.txt"));
 
  4746 	fileName1.Append(_L("File2GB.txt"));
 
  4752 	RFile64 file;
 
  4747 	RFile64 file;
 
  4753 	TInt r = file.Replace(TheFs, fileName1, EFileWrite);
 
  4748 	TInt r = file.Replace(TheFs, fileName1, EFileWrite);
 
  4754 	test_KErrNone(r);
 
  4749 	test (r == KErrNone);
 
  4755 	file.SetSize(K2GB);
 
  4750 	file.SetSize(K2GB);
 
  4756 	test_KErrNone(r);
 
  4751 	test (r == KErrNone);
 
  4757 	file.Close();
 
  4752 	file.Close();
 
  4758 	TestRFs.ReadFileSection(fileName1,0,readBuf,100);
 
  4753 	TestRFs.ReadFileSection(fileName1,0,readBuf,100);
 
  4759 	r = TheFs.Delete(fileName1);
 
  4754 	r = TheFs.Delete(fileName1);
 
  4760 	test_KErrNone(r);
 
  4755 	test (r == KErrNone);
 
  4761 	test.Next(_L("Creating test pattern"));
 
  4756 	test.Next(_L("Creating test pattern"));
 
  4762 	
  4757 	
  4763 	TBuf8<0x63> writeBuf63;
 
  4758 	TBuf8<0x63> writeBuf63;
 
  4764 	TBuf8<0x63> readBuf63;
 
  4759 	TBuf8<0x63> readBuf63;
 
  4765 	for (TInt count = 0; count < 0x63; count++)
 
  4760 	for (TInt count = 0; count < 0x63; count++)
 
  4789 	
  4784 	
  4790 	TestRFile2.Close();
 
  4785 	TestRFile2.Close();
 
  4791 	TestRFile1.Close();
 
  4786 	TestRFile1.Close();
 
  4792 	
  4787 	
  4793 	r = TheFs.Delete(fileName);
 
  4788 	r = TheFs.Delete(fileName);
 
  4794 	test_KErrNone(r);
 
  4789 	test(r == KErrNone);
 
  4795 	test.End();
 
  4790 	test.End();
 
  4796 	}
 
  4791 	}
 
  4797 
  4792 
  4798 /**
 
  4793 /**
 
  4799 @SYMTestCaseID      PBASE-T_FILE64BIT-2349
 
  4794 @SYMTestCaseID      PBASE-T_FILE64BIT-2349
 
  4940 		}
 
  4935 		}
 
  4941 
  4936 
  4942 	TestRFile1.Close();
 
  4937 	TestRFile1.Close();
 
  4943 	
  4938 	
  4944 	TInt r = TheFs.Delete(fileName);
 
  4939 	TInt r = TheFs.Delete(fileName);
 
  4945 	test_KErrNone(r);
 
  4940 	test(r == KErrNone);
 
  4946 	test.End();	
  4941 	test.End();	
  4947 	}	
  4942 	}	
  4948 
  4943 
  4949 /**
 
  4944 /**
 
  4950 @SYMTestCaseID      PBASE-T_FILE64BIT-2350
 
  4945 @SYMTestCaseID      PBASE-T_FILE64BIT-2350
 
  5079 		TestRFile1.Read(readBufx63, status8); // validating the content
 
  5074 		TestRFile1.Read(readBufx63, status8); // validating the content
 
  5080 		}
 
  5075 		}
 
  5081 	TestRFile1.Close();
 
  5076 	TestRFile1.Close();
 
  5082 	
  5077 	
  5083 	TInt r = TheFs.Delete(fileName);
 
  5078 	TInt r = TheFs.Delete(fileName);
 
  5084 	test_KErrNone(r);
 
  5079 	test(r == KErrNone);
 
  5085 	test.End();	
  5080 	test.End();	
  5086 	}	
  5081 	}	
  5087 
  5082 
  5088 /**
 
  5083 /**
 
  5089 @SYMTestCaseID      PBASE-T_FILE64BIT-2351
 
  5084 @SYMTestCaseID      PBASE-T_FILE64BIT-2351
 
  5226 		}
 
  5221 		}
 
  5227 
  5222 
  5228 	TestRFile1.Close();
 
  5223 	TestRFile1.Close();
 
  5229 	
  5224 	
  5230 	TInt r = TheFs.Delete(fileName);
 
  5225 	TInt r = TheFs.Delete(fileName);
 
  5231 	test_KErrNone(r);
 
  5226 	test(r == KErrNone);
 
  5232 	test.End();	
  5227 	test.End();	
  5233 	}	
  5228 	}	
  5234 /**
 
  5229 /**
 
  5235 @SYMTestCaseID      PBASE-T_FILE64BIT-2352
 
  5230 @SYMTestCaseID      PBASE-T_FILE64BIT-2352
 
  5236 @SYMTestPriority    High
 
  5231 @SYMTestPriority    High
 
  5378 		TRequestStatus status8 = KRequestPending;;	
  5373 		TRequestStatus status8 = KRequestPending;;	
  5379 		TestRFile1.Read(readBufx63,99,status8); 
  5374 		TestRFile1.Read(readBufx63,99,status8); 
  5380 		}
 
  5375 		}
 
  5381 	TestRFile1.Close();
 
  5376 	TestRFile1.Close();
 
  5382 	TInt r = TheFs.Delete(fileName);
 
  5377 	TInt r = TheFs.Delete(fileName);
 
  5383 	test_KErrNone(r);
 
  5378 	test(r == KErrNone);
 
  5384 	test.End();	
  5379 	test.End();	
  5385 	}	
  5380 	}	
  5386 /**
 
  5381 /**
 
  5387 @SYMTestCaseID      PBASE-T_FILE64BIT-2353
 
  5382 @SYMTestCaseID      PBASE-T_FILE64BIT-2353
 
  5388 @SYMTestPriority    High
 
  5383 @SYMTestPriority    High
 
  5462 			test(writeBuf == readBuf); // Written data == Read data
 
  5457 			test(writeBuf == readBuf); // Written data == Read data
 
  5463 			}
 
  5458 			}
 
  5464 		}
 
  5459 		}
 
  5465 	TestRFile1.Close();
 
  5460 	TestRFile1.Close();
 
  5466 	TInt r = TheFs.Delete(fileName);
 
  5461 	TInt r = TheFs.Delete(fileName);
 
  5467 	test_KErrNone(r);
 
  5462 	test(r == KErrNone);
 
  5468 	}
 
  5463 	}
 
  5469 /**
 
  5464 /**
 
  5470 @SYMTestCaseID      PBASE-T_FILE64BIT-2354
 
  5465 @SYMTestCaseID      PBASE-T_FILE64BIT-2354
 
  5471 @SYMTestPriority    High
 
  5466 @SYMTestPriority    High
 
  5472 @SYMTestRequirement REQ9532
 
  5467 @SYMTestRequirement REQ9532
 
  5590 	TestRFile1.Write(_L8("1234567891"));
 
  5585 	TestRFile1.Write(_L8("1234567891"));
 
  5591 	TestRFile1.Close();
 
  5586 	TestRFile1.Close();
 
  5592 
  5587 
  5593 	test.Next(_L("Copy the files from one folder to another using CFileMan::Copy()\n"));
 
  5588 	test.Next(_L("Copy the files from one folder to another using CFileMan::Copy()\n"));
 
  5594 	TInt r = fileMan->Copy(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
 
  5589 	TInt r = fileMan->Copy(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
 
  5595 	test_Value(r, r == KErrNone || r == KErrTooBig);
 
  5590 	test(r == KErrNone || r == KErrTooBig);
 
  5596 
  5591 
  5597 	test.Next(_L("Get the directory entry and find how many files are copied\n"));
 
  5592 	test.Next(_L("Get the directory entry and find how many files are copied\n"));
 
  5598 	// check SMALL and LARGE files have been copied
 
  5593 	// check SMALL and LARGE files have been copied
 
  5599 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
 
  5594 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
 
  5600 	test_KErrNone(r);
 
  5595 	test (r == KErrNone);
 
  5601 	r = dir.Read(entryArray);
 
  5596 	r = dir.Read(entryArray);
 
  5602 	test_Value(r, r == KErrEof);
 
  5597 	test (r == KErrEof);
 
  5603 	test(entryArray.Count() == gFilesInDirectory);
 
  5598 	test(entryArray.Count() == gFilesInDirectory);
 
  5604 	dir.Close();
 
  5599 	dir.Close();
 
  5605 	
  5600 	
  5606 	// then delete the new directory
 
  5601 	// then delete the new directory
 
  5607 	r = fileMan->Delete(filePathNew);
 
  5602 	r = fileMan->Delete(filePathNew);
 
  5608 	test_KErrNone(r);
 
  5603 	test(r == KErrNone);
 
  5609 
  5604 
  5610 	test.Next(_L("Set file man observer\n"));
 
  5605 	test.Next(_L("Set file man observer\n"));
 
  5611 	// attempt to copy to new directory again - this time with an observer
 
  5606 	// attempt to copy to new directory again - this time with an observer
 
  5612 	fileMan->SetObserver(observer);
 
  5607 	fileMan->SetObserver(observer);
 
  5613 	
  5608 	
  5614 	test.Next(_L("Copy the files from one folder to another, source folder has 3 small files and a large file\n"));
 
  5609 	test.Next(_L("Copy the files from one folder to another, source folder has 3 small files and a large file\n"));
 
  5615 	r = fileMan->Copy(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
 
  5610 	r = fileMan->Copy(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
 
  5616 	test_Value(r, r == KErrNone || r == KErrTooBig);
 
  5611 	test(r == KErrNone || r == KErrTooBig);
 
  5617 	
  5612 	
  5618 	test.Next(_L("Check observer for number of successful copy and failed copy\n"));
 
  5613 	test.Next(_L("Check observer for number of successful copy and failed copy\n"));
 
  5619 	// test that 3 small files and 1 large file were copied
 
  5614 	// test that 3 small files and 1 large file were copied
 
  5620 	// (For 8 GB disk, the 4GB file is missing)
 
  5615 	// (For 8 GB disk, the 4GB file is missing)
 
  5621 	test(observer->iNotifyEndedSuccesses == gFilesInDirectory);
 
  5616 	test(observer->iNotifyEndedSuccesses == gFilesInDirectory);
 
  5622 	test(observer->iNotifyEndedFailures == 0); 
  5617 	test(observer->iNotifyEndedFailures == 0); 
  5623 
  5618 
  5624 	test.Next(_L("Get the directory entry and find how many files copied\n"));
 
  5619 	test.Next(_L("Get the directory entry and find how many files copied\n"));
 
  5625 	// check SMALL files have been copied
 
  5620 	// check SMALL files have been copied
 
  5626 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
 
  5621 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
 
  5627 	test_KErrNone(r);
 
  5622 	test (r == KErrNone);
 
  5628 	r = dir.Read(entryArray);
 
  5623 	r = dir.Read(entryArray);
 
  5629 	test_Value(r, r == KErrEof);
 
  5624 	test (r == KErrEof);
 
  5630 
  5625 
  5631 	test(entryArray.Count() == gFilesInDirectory); 
  5626 	test(entryArray.Count() == gFilesInDirectory); 
  5632 	dir.Close();
 
  5627 	dir.Close();
 
  5633 	
  5628 	
  5634 	// then delete the new directory
 
  5629 	// then delete the new directory
 
  5635 	r = fileMan->Delete(filePathNew);
 
  5630 	r = fileMan->Delete(filePathNew);
 
  5636 	test_KErrNone(r);
 
  5631 	test(r == KErrNone);
 
  5637 
  5632 
  5638 	delete observer;
 
  5633 	delete observer;
 
  5639 	delete fileMan;
 
  5634 	delete fileMan;
 
  5640 	
  5635 	
  5641 	r = TheFs.Delete(fileSmall1);
 
  5636 	r = TheFs.Delete(fileSmall1);
 
  5642 	test_KErrNone(r);
 
  5637 	test(r == KErrNone);
 
  5643 	r = TheFs.Delete(fileSmall2);
 
  5638 	r = TheFs.Delete(fileSmall2);
 
  5644 	test_KErrNone(r);
 
  5639 	test(r == KErrNone);
 
  5645 	r = TheFs.Delete(fileSmall3);
 
  5640 	r = TheFs.Delete(fileSmall3);
 
  5646 	test_KErrNone(r);
 
  5641 	test(r == KErrNone);
 
  5647 	r = TheFs.Delete(fileLarge1);
 
  5642 	r = TheFs.Delete(fileLarge1);
 
  5648 	test_KErrNone(r);
 
  5643 	test(r == KErrNone);
 
  5649 	}
 
  5644 	}
 
  5650 /**
 
  5645 /**
 
  5651 @SYMTestCaseID      PBASE-T_FILE64BIT-2355
 
  5646 @SYMTestCaseID      PBASE-T_FILE64BIT-2355
 
  5652 @SYMTestPriority    High
 
  5647 @SYMTestPriority    High
 
  5653 @SYMTestRequirement REQ9532
 
  5648 @SYMTestRequirement REQ9532
 
  5721 	TestRFile1.Close();
 
  5716 	TestRFile1.Close();
 
  5722 	
  5717 	
  5723 
  5718 
  5724 	// move to new directory
 
  5719 	// move to new directory
 
  5725 	TInt r = fileMan->Move(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
 
  5720 	TInt r = fileMan->Move(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
 
  5726 	test_Value(r, r == KErrNone || r == KErrTooBig);
 
  5721 	test(r == KErrNone || r == KErrTooBig);
 
  5727 
  5722 
  5728 	// check SMALL and LARGE files have been moved
 
  5723 	// check SMALL and LARGE files have been moved
 
  5729 	RDir dir;
 
  5724 	RDir dir;
 
  5730 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
 
  5725 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
 
  5731 	test_KErrNone(r);
 
  5726 	test (r == KErrNone);
 
  5732 	TEntryArray entryArray;
 
  5727 	TEntryArray entryArray;
 
  5733 	r = dir.Read(entryArray);
 
  5728 	r = dir.Read(entryArray);
 
  5734 	test_Value(r, r == KErrEof);
 
  5729 	test (r == KErrEof);
 
  5735 	test(entryArray.Count() == 4);
 
  5730 	test(entryArray.Count() == 4);
 
  5736 	dir.Close();
 
  5731 	dir.Close();
 
  5737 	
  5732 	
  5738 	// then delete the new directory
 
  5733 	// then delete the new directory
 
  5739 	r = fileMan->Delete(filePathNew);
 
  5734 	r = fileMan->Delete(filePathNew);
 
  5740 	test_KErrNone(r);
 
  5735 	test(r == KErrNone);
 
  5741 	delete fileMan;
 
  5736 	delete fileMan;
 
  5742 	}
 
  5737 	}
 
  5743 
  5738 
  5744 
  5739 
  5745 static void TestOpenFiles()
 
  5740 static void TestOpenFiles()
 
  5759 static void TestAdoptFiles()
 
  5754 static void TestAdoptFiles()
 
  5760 	{
 
  5755 	{
 
  5761 	TInt r;
 
  5756 	TInt r;
 
  5762 	RFs fs;
 
  5757 	RFs fs;
 
  5763 	r = fs.Connect();
 
  5758 	r = fs.Connect();
 
  5764 	test_KErrNone(r);
 
  5759 	test(r == KErrNone);
 
  5765 	r = fs.ShareProtected();
 
  5760 	r = fs.ShareProtected();
 
  5766 	test_KErrNone(r);
 
  5761 	test(r == KErrNone);
 
  5767 	TFileName sessionp;
 
  5762 	TFileName sessionp;
 
  5768 	fs.SessionPath(sessionp);
 
  5763 	fs.SessionPath(sessionp);
 
  5769 	r = fs.MkDirAll(sessionp);
 
  5764 	r = fs.MkDirAll(sessionp);
 
  5770 	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 
  5765 	test(r == KErrNone || r == KErrAlreadyExists);
 
  5771 	fs.Close();
 
  5766 	fs.Close();
 
  5772 	TestRFile64AdoptFromCreator();
 
  5767 	TestRFile64AdoptFromCreator();
 
  5773 	TestRFile64AdoptFromClient();
 
  5768 	TestRFile64AdoptFromClient();
 
  5774 	TestRFile64AdoptFromServer();
 
  5769 	TestRFile64AdoptFromServer();
 
  5775 	}
 
  5770 	}
 
  5905 	TRequestStatus status1=KRequestPending;
 
  5900 	TRequestStatus status1=KRequestPending;
 
  5906 	TRequestStatus status2=KRequestPending;
 
  5901 	TRequestStatus status2=KRequestPending;
 
  5907 	
  5902 	
  5908 	// If a zero length is passed into the Write function, KErrNone should be returned. 
  5903 	// If a zero length is passed into the Write function, KErrNone should be returned. 
  5909 	r=aFile.Write(aPos,gBuf);
 
  5904 	r=aFile.Write(aPos,gBuf);
 
  5910 	test_KErrNone(r);
 
  5905 	test(r==KErrNone);
 
  5911 	
  5906 	
  5912 	// If the length is a negative, KErrArgument should be returned. 
  5907 	// If the length is a negative, KErrArgument should be returned. 
  5913 	r=aFile.Write(aPos,gBuf,aLen);
 
  5908 	r=aFile.Write(aPos,gBuf,aLen);
 
  5914 	test_Value(r, r == KErrArgument);
 
  5909 	test(r==KErrArgument);
 
  5915 	
  5910 	
  5916 	// Test the asynchronous requests
 
  5911 	// Test the asynchronous requests
 
  5917 	aFile.Write(aPos,gBuf,aLen,status1);
 
  5912 	aFile.Write(aPos,gBuf,aLen,status1);
 
  5918 	aFile.Write(aPos,gBuf,aLen,status2);
 
  5913 	aFile.Write(aPos,gBuf,aLen,status2);
 
  5919 	User::WaitForRequest(status1);
 
  5914 	User::WaitForRequest(status1);
 
  5921 	User::WaitForRequest(status2);
 
  5916 	User::WaitForRequest(status2);
 
  5922 	test(status2.Int()==KErrArgument);
 
  5917 	test(status2.Int()==KErrArgument);
 
  5923 	
  5918 	
  5924 	aFile.Close();
 
  5919 	aFile.Close();
 
  5925 	r = TheFs.Delete(_L("\\testRFile64NegLen.txt"));
 
  5920 	r = TheFs.Delete(_L("\\testRFile64NegLen.txt"));
 
  5926 	test_KErrNone(r);
 
  5921 	test(r == KErrNone);
 
  5927 	test.End();	
  5922 	test.End();	
  5928 	}
 
  5923 	}
 
  5929 //-------------------------------------------------------------------------------------------------------------------
 
  5924 //-------------------------------------------------------------------------------------------------------------------
 
  5930 
  5925 
  5931 static TInt PrepareDisk(TInt aDrive)
 
  5926 static TInt PrepareDisk(TInt aDrive)
 
  5959     //-- decide if we need to test files >= 4G. As soon as there is no appropriate API yet, this way is dodgy..
 
  5954     //-- decide if we need to test files >= 4G. As soon as there is no appropriate API yet, this way is dodgy..
 
  5960     if(Is_Fat(TheFs, aDrive))
 
  5955     if(Is_Fat(TheFs, aDrive))
 
  5961         {
 
  5956         {
 
  5962         KFileSizeMaxLargerThan4GBMinusOne = EFalse; //-- FAT doesn't support >= 4G files
 
  5957         KFileSizeMaxLargerThan4GBMinusOne = EFalse; //-- FAT doesn't support >= 4G files
 
  5963         }
 
  5958         }
 
  5964     else if(Is_SimulatedSystemDrive(TheFs, aDrive))
 
  5959     else if(Is_Win32(TheFs, aDrive))
 
  5965         {
 
  5960         {//-- this is the emulator's windows drive. The maximal file size depends on the Windows FS used for this drive.
 
  5966 		 //-- This is the emulator's windows drive or PlatSim's HVFS.
 
  5961          //-- if it is NTFS, files >= 4G are supported.   
  5967 		 //-- The maximal file size depends on the Windows FS used for this drive.
 
       
  5968          //-- If it is NTFS, files >= 4G are supported.
 
       
  5969         r = CreateEmptyFile(TheFs, _L("\\test_file"), K4GB);
 
  5962         r = CreateEmptyFile(TheFs, _L("\\test_file"), K4GB);
 
  5970         
  5963         
  5971         KFileSizeMaxLargerThan4GBMinusOne = (r == KErrNone);
 
  5964         KFileSizeMaxLargerThan4GBMinusOne = (r == KErrNone);
 
  5972         r = TheFs.Delete(_L("\\test_file"));
 
  5965         r = TheFs.Delete(_L("\\test_file"));
 
  5973 
  5966 
  5985 
  5978 
  5986 void CallTestsL()
 
  5979 void CallTestsL()
 
  5987 	{
 
  5980 	{
 
  5988 	TInt r;
 
  5981 	TInt r;
 
  5989 	r = RFs::CharToDrive(gDriveToTest, gDrive);
 
  5982 	r = RFs::CharToDrive(gDriveToTest, gDrive);
 
  5990 	test_KErrNone(r);
 
  5983 	test(r == KErrNone);
 
  5991 
  5984 
  5992     //-- set up console output 
  5985     //-- set up console output 
  5993     F32_Test_Utils::SetConsole(test.Console()); 
  5986     F32_Test_Utils::SetConsole(test.Console()); 
  5994 
  5987 
  5995     PrintDrvInfo(TheFs, gDrive);
 
  5988     PrintDrvInfo(TheFs, gDrive);
 
  6034 	// Delete the test directory
 
  6027 	// Delete the test directory
 
  6035 	TFileName dirName;
 
  6028 	TFileName dirName;
 
  6036 	dirName.Append(gDriveToTest);
 
  6029 	dirName.Append(gDriveToTest);
 
  6037 	dirName.Append(KTestPath);
 
  6030 	dirName.Append(KTestPath);
 
  6038 	r = TheFs.RmDir(dirName);
 
  6031 	r = TheFs.RmDir(dirName);
 
  6039 	test_KErrNone(r);
 
  6032 	test(r == KErrNone);
 
  6040 	}
 
  6033 	}
 
  6041 
  6034 
  6042 
  6035 
  6043 
  6036 
  6044 
  6037 
  6045 
  6038 
  6046 
  6039 
  6047 
  6040
FCL/sf/os/kernelhwsrv