1 /*

     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 #include "tsyscalls.h"

    20 #include <unistd.h>

    21 #include <fcntl.h>

    22 #include <stdio.h>

    23 #include <errno.h>

    24 #include <dirent.h>

    25 #include <sys/stat.h>

    26 #include <stdlib.h>

    27 #include <string.h>

    28 #include <utime.h>

    29 #include <time.h>

    30 #include <sys/wait.h>

    31 #include <sys/uio.h>

    32 #include <sys/syslimits.h>

    33 #include <pthread.h>

    34 #include <sys/types.h>  

    35 #include <sys/utsname.h>

    36 

    37 #define CLOCKS_PER_SEC 128

    38 

    39 /*******************************************************************************

    40 

    41   Test case : open1 creates a file Prog1.txt  in cdrive

    42               opens the file file in read-write mode 

    43               

    44        return : 0 on success 

    45 

    46                 

    47 *******************************************************************************/                           

    48 

    49 TInt CTestSyscalls :: Creat(  )

    50 	{

    51     int fd ;

    52     TPtrC String ;

    53     mkdir("C:\\Test" , S_IWUSR);

    54     _LIT( KString, "String" );

    55     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

    56     if(!res)  

    57 		{

    58      	_LIT(Kerr , "Failed to read input file name") ;

    59      	INFO_PRINTF1(Kerr) ;

    60 		return KErrGeneral ;

    61 		}

    62     TBuf8<100> string1;

    63 	string1.Copy(String);

    64 	char* file = (char*) string1.Ptr();

    65 	file[string1.Length()]='\0';

    66 	 	 

    67 		

    68     // Print to UI

    69    

    70     _LIT( KOpen1, "In create" );

    71   

    72     unlink(file) ; 

    73     INFO_PRINTF1( KOpen1 );

    74    

    75     if((fd = creat(file ,  0666))  < 0) 

    76 		{

    77         _LIT(Kerr , "failed to open the file ") ;

    78         INFO_PRINTF1(Kerr) ;

    79     	return KErrGeneral ;

    80 		}

    81     close(fd) ;

    82     return KErrNone ;

    83     

    84     }

    85 

    86 

    87 /*******************************************************************************

    88 

    89   Test case : open1 creates a file Prog1.txt  in cdrive

    90               opens the file file in read-write mode 

    91               

    92        return : 0 on success 

    93 

    94                 

    95 *******************************************************************************/                           

    96 

    97 TInt CTestSyscalls::open1(  )

    98     {

    99 	int fd ;

   100     TPtrC String ;

   101     TInt IsDirectory ;        // This variable is used to find wheather a directory is 

   102                               //is opened    

   103     TInt Expected ; 

   104      

   105     _LIT( KString, "String" );

   106     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   107     if(!res)  

   108 		{

   109      	_LIT(Kerr , "Failed to read input file name") ;

   110      	INFO_PRINTF1(Kerr) ;

   111      	return KErrGeneral ;

   112 		}

   113      

   114     TBuf8<100> string1;

   115 	string1.Copy(String);

   116 	char* file = (char*) string1.Ptr();

   117 	file[string1.Length()]='\0';

   118 	 

   119 	_LIT( KIsDirectory, "IsDirectory" );

   120 	res = GetIntFromConfig(ConfigSection(), KIsDirectory, IsDirectory);

   121 	 

   122 	if(!res)

   123 		{

   124 	 	_LIT(Kerr , "Failed to read directory flag") ;

   125 	 	INFO_PRINTF1(Kerr) ;

   126 	 	return KErrGeneral ;

   127 		}

   128 	 

   129 	_LIT( KExpected, "Expected" );

   130 	res = GetIntFromConfig(ConfigSection(), KExpected, Expected);

   131 	if(!res)

   132 		{

   133 	 	_LIT(Kerr , "Failed to read directory flag") ;

   134 	 	INFO_PRINTF1(Kerr) ;

   135 	 	return KErrGeneral ;

   136 		}

   137 	 

   138 	if(Expected < 0 ) 

   139 		{

   140 		fd = open(NULL , O_CREAT | O_RDWR  , 0444) ;

   141 	   

   142 		if(fd < 0)  

   143 			{

   144 	   		if(errno != EFAULT) 

   145 	   			{

   146 	   			_LIT(Kerr , "Failed to set the errno value for open system call") ;

   147 	   			INFO_PRINTF1(Kerr) ;

   148 	   			return KErrGeneral ;

   149 	   			}

   150 	   		return KErrNone ; 

   151 			}

   152 		_LIT(Kerr , "open for NULL address should fail") ;

   153 		INFO_PRINTF1(Kerr) ;

   154 		return KErrGeneral ;

   155 		}

   156 	 

   157 		

   158     _LIT( KTsyscalls, "Tsyscalls" );

   159     INFO_PRINTF1(KTsyscalls) ;

   160     _LIT( KOpen1, "In open1" );

   161   

   162     unlink(file) ; 

   163     INFO_PRINTF1( KOpen1 );

   164    

   165     if((fd = open(file , O_CREAT | O_RDWR , 0666))  < 0) 

   166 		{

   167         if(IsDirectory && (errno == EISDIR) )   

   168 			{

   169         	_LIT(Kerrnone , "Directory open test case passes ") ;

   170         	INFO_PRINTF1(Kerrnone) ;

   171         	return KErrNone ;

   172 			}

   173         else if(IsDirectory) 

   174 			{

   175         	_LIT(Kerr , "Directory open test case fails to set err value") ;

   176         	INFO_PRINTF1(Kerr) ;

   177         	return KErrGeneral ;

   178 			}

   179 		_LIT(Kerr , "failed to open the file ") ;

   180 		INFO_PRINTF1(Kerr) ;

   181     	return KErrGeneral ;

   182 		}

   183    

   184     close(fd) ;

   185     return KErrNone ;

   186     

   187     }

   188 

   189 

   190 //-------------------------------------------------------------------------------

   191 

   192 //  Test case : open2 creates a file

   193 //              opens in write only mode

   194 //              return : 0 on success 

   195 //              1 failure

   196 //--------------------------------------------------------------------------------                  

   197 TInt CTestSyscalls :: open2()

   198 	{

   199 	int fd ;

   200 	TPtrC String ;

   201     _LIT( KString, "String" );

   202      TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   203 	if(res)

   204 		{

   205 	    TBuf8<100> string1;

   206 		

   207 		string1.Copy(String);

   208 		char* file = (char*) string1.Ptr();

   209 		file[string1.Length()]='\0';

   210 	    _LIT( KOpen3, "In open3" );

   211 	  

   212 	    INFO_PRINTF1( KOpen3 );

   213 	    unlink(file);

   214 

   215 	    if((fd = open(file , O_CREAT | O_WRONLY , 0666))  < 0) 

   216 			{

   217 			return KErrGeneral ;

   218 			}

   219 	    close(fd) ;

   220 		}

   221     return KErrNone ;

   222     

   223 	}

   224 

   225 //-------------------------------------------------------------------------------

   226 

   227 //  Test case : open3 creates a file

   228 //              opens in readonly mode

   229 //              return : 0 on success 

   230 

   231 //--------------------------------------------------------------------------------                  

   232 TInt CTestSyscalls :: open3()

   233 	{

   234 	int fd ;

   235 	TPtrC String ;

   236      

   237 	_LIT( KString, "String" );

   238     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   239 	if(res)

   240 		{

   241 	    TBuf8<100> string1;

   242 		string1.Copy(String);

   243 		char* file = (char*) string1.Ptr();

   244 		file[string1.Length()]='\0';

   245 		

   246 		_LIT( KOpen3, "In open3" );

   247 	    INFO_PRINTF1( KOpen3 );

   248 	    

   249 	    unlink(file);

   250 	    if((fd = open(file ,  O_RDONLY | O_CREAT , 0666))  < 0) 

   251 			{

   252 	        return KErrGeneral ;

   253 			}

   254 	    close(fd) ;

   255 	    return KErrNone  ;

   256 		}

   257 	else

   258 		{

   259 		return KErrGeneral;

   260 		}

   261 	}

   262 

   263 

   264 

   265 //-------------------------------------------------------------------------------

   266 

   267 //  Test case : open4 creates a file  (Negative testcase )

   268 //   

   269 //  Tries to open a fails  in invalid  mode           

   270 //             

   271 // Create a file Exclusively

   272 //--------------------------------------------------------------------------------                  

   273 

   274 

   275 TInt CTestSyscalls :: open4()

   276 	{

   277 	int fd ;

   278    

   279 	TBuf8<100> string1;

   280 	TPtrC String ;

   281     

   282 	_LIT( KString, "String" );

   283 	TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   284 	if(!res)

   285 		{

   286 	    _LIT(Kerr , " Failed to  read input file name from ini file ") ;

   287 	    INFO_PRINTF1(Kerr) ;

   288 	    return KErrGeneral ;

   289 		}

   290 	    

   291 	string1.Copy(String);

   292 	char* file = (char*) string1.Ptr();

   293 	file[string1.Length()]='\0';

   294 	_LIT( KOpen4, "In open4" );

   295 	INFO_PRINTF1( KOpen4 );

   296     if((fd = open(file , O_CREAT | O_RDWR  , 0666))  < 0) 

   297 		{

   298         _LIT(Kerr , "Failed to o given file name") ;

   299         INFO_PRINTF1(Kerr) ;

   300         return  KErrGeneral  ;

   301 		}

   302     close(fd) ;

   303     

   304     //Now try to open the file exclusively , this open sustem call should fail

   305     

   306     fd = open(file , O_CREAT | O_EXCL | O_RDWR , 0666) ;

   307     if(fd < 0 )  

   308 		{

   309     	if(errno != EEXIST) 

   310     		{

   311     		_LIT(Kerr , "Failed to set errno value for open syscall") ;

   312     		INFO_PRINTF1(Kerr) ;

   313     		return KErrGeneral ;

   314     		}

   315     	return KErrNone ;

   316 		}

   317 	_LIT(Kerr , "Failed to open a file in O_EXCL mode ") ;

   318 	INFO_PRINTF1(Kerr) ;

   319 	return KErrGeneral ;

   320 	}

   321 

   322 

   323 //-------------------------------------------------------------------------------

   324 

   325 //  Test case : open5 creates a file  (Negative testcase )

   326 //   

   327 //  Tries to open a fails  in invalid  path

   328 //             

   329 // 

   330 //--------------------------------------------------------------------------------                  

   331 

   332 

   333 TInt CTestSyscalls :: open5()

   334 	{

   335 	int fd ;

   336 	

   337     TInt ret = KErrNone ;

   338 	TBuf8<100> string1;

   339     TPtrC String ;

   340     

   341 	_LIT( KString, "String" );

   342 	TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   343 

   344     if(!res)    

   345 		{

   346     	_LIT(Kerr , "Failed to read input file name from ini file") ;

   347     	INFO_PRINTF1(Kerr) ;

   348     	return KErrGeneral ;

   349 		}

   350 	string1.Copy(String);

   351 	char* file = (char*) string1.Ptr();

   352 	file[string1.Length()]='\0';

   353 	

   354 	_LIT( KOpen5, "In open5" );

   355    

   356     INFO_PRINTF1( KOpen5 );

   357     unlink(file);

   358 

   359     

   360     if((fd = open(file , O_CREAT | O_RDONLY , 0666))  < 0) 

   361 		{

   362         if(errno != ENOENT)   

   363 			{

   364         	_LIT(Kinvalidpath , "failed to  set errno value ") ;

   365         	INFO_PRINTF1(Kinvalidpath);

   366         	ret = KErrGeneral ;

   367 			}

   368         }

   369     else 

   370 		{

   371        _LIT(Kerr , "File opened in an invalid path test fails ") ;

   372 	   close(fd);

   373        INFO_PRINTF1(Kerr) ;

   374        ret = KErrGeneral ;

   375 		}

   376 	close(fd) ;

   377 	return ret ;    //This ret will be set to KErrNone if all test cases are though

   378 	}

   379 

   380 

   381 //-------------------------------------------------------------------------------

   382 

   383 //  Test case : open6 truncates the file //   

   384 //  

   385 //             

   386 // 

   387 //--------------------------------------------------------------------------------                  

   388 

   389 

   390 TInt CTestSyscalls :: open6()

   391 	{

   392 	int fd ;

   393 	TBuf8<100> string1;

   394     TPtrC String ;

   395     

   396     _LIT( KString, "String" );

   397 	TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   398 

   399     if(!res)   

   400 		{

   401     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   402     	INFO_PRINTF1(Kerr) ;

   403     	return KErrGeneral ;

   404 		}

   405 	string1.Copy(String);

   406 	char* file = (char*) string1.Ptr();

   407 	file[string1.Length()]='\0';

   408 	

   409     _LIT( KOpen5, "In open6" );

   410     INFO_PRINTF1( KOpen5 );

   411   

   412     unlink(file);

   413 

   414     if((fd = open(file , O_CREAT|O_RDWR , 0666))  < 0) 

   415 		{

   416         _LIT(Kinvalidarg , "Failed to open specified file \n")  ;

   417         INFO_PRINTF1(Kinvalidarg) ;

   418         return KErrGeneral ;

   419 		}

   420     if(write(fd , "hELLO" ,6) < 0) 

   421 		{

   422 		_LIT(Kerr , "Failed to write to the file D:\\Prog1.txt") ;

   423 		INFO_PRINTF1(Kerr) ;

   424 		close(fd) ;

   425 		return KErrGeneral ;

   426 		}

   427     close(fd) ;

   428     if((fd = open(file , O_CREAT|O_RDWR|O_TRUNC , 0666))  < 0)  

   429 		{

   430     	_LIT(Kerr , "Failed to tuncate the specified file ") ;

   431     	INFO_PRINTF1(Kerr) ;

   432     	return KErrGeneral ;

   433 		}

   434     //seek  and find out the  size of the file

   435     

   436     if(lseek(fd , 0 , SEEK_END) != 0 )  

   437 		{

   438     	_LIT(Kerr , "file could not be truncated ") ;

   439     	INFO_PRINTF1(Kerr) ;

   440 		close(fd);

   441     	return  KErrGeneral ;

   442 		}

   443 	close(fd);

   444     return KErrNone ; 

   445     

   446 	}

   447 

   448 /**

   449  * Testcase 	:	OpenTruncate1

   450  * Description	: 	Open a file with O_CREAT | ORDWR flag

   451  * 					Re-open the same file with O_TRUNC

   452  * 					stat on the file to check whether the file is trunctaed or not

   453  * Return value	:	KErrNone

   454  */

   455 TInt CTestSyscalls :: OpenTruncate1()

   456 	{

   457 	int fd1, fd2, ret;

   458 	TBuf8<128> string1;

   459 	TPtrC String ;

   460 	struct stat fInfo;

   461 	

   462 	_LIT( KString, "String" );

   463 	TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   464 	

   465 	if(!res)   

   466 		{

   467 	   	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   468 	   	INFO_PRINTF1(Kerr);

   469 	   	return KErrGeneral;

   470 		}

   471 	string1.Copy(String);

   472 	char* file = (char*) string1.Ptr();

   473 	file[string1.Length()]='\0';

   474 	

   475 	if((fd1 = open(file, O_CREAT | O_RDWR)) < 0)

   476 		{

   477 		INFO_PRINTF2(_L("file open failed with error number %d"), errno);

   478 		return KErrGeneral;

   479 		}

   480 	

   481 	if ((write(fd1, "Symbian", 7)) != 7)

   482 		{

   483 		INFO_PRINTF2(_L("write failed with error number %d"), errno);

   484 		close(fd1);

   485 		unlink(file);

   486 		return KErrGeneral;

   487 		}

   488 	

   489 	// re-open the same file with O_CREAT

   490 	if((fd2 = open(file, O_TRUNC | O_WRONLY)) < 0)

   491 		{

   492 		INFO_PRINTF2(_L("file open with O_TRUNC failed with error number %d"), errno);

   493 		close(fd1);

   494 		unlink(file);

   495 		return KErrGeneral;

   496 		}

   497 	

   498 	ret = stat(file, &fInfo);

   499 	

   500 	if (ret == -1)

   501 		{

   502 		INFO_PRINTF2(_L("stat failed with error number %d"), errno);

   503 		close(fd1);

   504 		unlink(file);

   505 		return KErrGeneral;		

   506 		}

   507 	

   508 	if(fInfo.st_size != 0)

   509 		{

   510 		INFO_PRINTF1(_L("The file is not truncated. Testcase failed"));

   511 		close(fd1);

   512 		unlink(file);

   513 		return KErrGeneral;

   514 		}

   515 	

   516 	close(fd2);

   517 	unlink(file);

   518 	return KErrNone;

   519 	}

   520 

   521 /**

   522  * Testcase 	:	OpenTruncate2

   523  * Description	: 	open a non existing file with flag O_TRUNC

   524  * 					It should not create a new file 

   525  * Return value	:	KErrNone

   526  */

   527 TInt CTestSyscalls :: OpenTruncate2()

   528 	{

   529 	int fd1, ret;

   530 	TBuf8<128> string1;

   531 	TPtrC String ;

   532 		

   533 	_LIT( KString, "String" );

   534 	TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   535 	

   536 	if(!res)   

   537 		{

   538 	   	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   539 	   	INFO_PRINTF1(Kerr);

   540 	   	return KErrGeneral;

   541 		}

   542 	string1.Copy(String);

   543 	char* file = (char*) string1.Ptr();

   544 	file[string1.Length()]='\0';

   545 	

   546 	if((fd1 = open(file, O_TRUNC)) < 0)

   547 		{

   548 		INFO_PRINTF1(_L("Test case passed"));

   549 		ret = KErrNone;

   550 		}

   551 	else

   552 		{

   553 		INFO_PRINTF1(_L("open with only flag O_TRUNC should not creat a new file. Test case failed"));

   554 		close(fd1);

   555 		unlink(file);

   556 		ret = KErrGeneral;

   557 		}

   558 	

   559 	close(fd1);

   560 	unlink(file);

   561 	return ret;

   562 	}

   563 //-----------------------------------------------------------------------------

   564 //  Try to open a read only file in  Write only mode

   565 

   566 //---------------------------------------------------------------------------

   567 

   568 TInt CTestSyscalls :: open7()

   569 	{

   570 	int fd ;

   571 	TInt ret = KErrNone ;

   572 	TBuf8<100> string1;

   573     TPtrC String ;

   574     

   575     _LIT( KString, "String" );

   576 	TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   577 

   578     if(!res)   

   579 		{

   580     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   581     	INFO_PRINTF1(Kerr) ;

   582     	return KErrGeneral ;

   583 		}

   584     

   585 	string1.Copy(String);

   586 	char* file = (char*) string1.Ptr();

   587 	file[string1.Length()]='\0';

   588 	

   589 	_LIT( KTsyscalls, "Tsyscalls" );

   590 	INFO_PRINTF1(KTsyscalls) ;

   591 	

   592     _LIT( KOpen7 , "In open7" );

   593     INFO_PRINTF1( KOpen7 );

   594     

   595     unlink(file) ;

   596     

   597     //First create read only file , close it and they try to 

   598     //open in W_ONLY mode 

   599     

   600     if((fd = open(file , O_CREAT|O_RDWR , 0444))  < 0) 

   601 		{

   602         _LIT(Kinvalidarg , "Failed to open specified file \n")  ;

   603         INFO_PRINTF1(Kinvalidarg) ;

   604         return KErrGeneral ;

   605 		}

   606     

   607     close(fd) ;

   608     

   609     if((fd = open(file , O_CREAT|O_WRONLY ) ) < 0) 

   610 		{

   611          if(errno !=EACCES)  

   612 			{

   613          	_LIT(Kerr , "Failed to set errno value ") ;

   614          	INFO_PRINTF1(Kerr);

   615          	ret = KErrGeneral ;

   616 			}        

   617 		}

   618     else

   619 		{

   620         _LIT(KErr , "Opened a read only file in Write mode hence failed ") ;

   621 		close(fd);

   622 		unlink(file);

   623         INFO_PRINTF1(KErr);

   624     	ret = KErrGeneral ;

   625 		}

   626     

   627     close(fd) ;

   628     chmod(file , S_IWUSR);

   629     unlink(file) ;

   630     return ret ; 

   631     

   632 	}

   633 

   634 

   635 

   636 /**

   637 * Function Name :	OpenInAppendMode

   638 * API Tested 	:	write

   639 * TestCase Description:	This test case is added as part of fix for DEF114524

   640 *						1. A file is opened in Append mode twice

   641 *						2. Few bytes are written into file using two different FIDs

   642 *						3. File is closed using both the FIDs

   643 * Expected result:	

   644 */

   645 TInt CTestSyscalls::OpenInAppendMode()

   646 	{

   647 	int fd[2];

   648 	char Buf[10+1];

   649 	TInt ret = KErrNone;

   650 	TBuf8<100> string1;

   651     TPtrC String;

   652     

   653     _LIT( KString, "String" );

   654 	TBool res = GetStringFromConfig(ConfigSection(), KString, String);

   655 

   656     if(!res)   

   657 		{

   658     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   659     	INFO_PRINTF1(Kerr) ;

   660     	return KErrGeneral ;

   661 		}

   662     

   663 	string1.Copy(String);

   664 	char* file = (char*) string1.Ptr();

   665 	file[string1.Length()]='\0';

   666 	

   667 	

   668 	if( (fd[0] = open(file, O_WRONLY | O_APPEND | O_CREAT)) < 0)

   669 		{

   670 		_LIT(KFail, "Failed to open file in append mode");

   671         INFO_PRINTF1(KFail);

   672         return KErrGeneral;

   673 		}

   674 		

   675 	if((fd[1] = open(file, O_WRONLY | O_APPEND | O_CREAT)) < 0)

   676 		{

   677 		_LIT(KFail, "Failed to open file in append mode");

   678         INFO_PRINTF1(KFail);

   679         return KErrGeneral;

   680 		}

   681 	

   682 	if((write(fd[0], "Test", 4)) != 4)

   683 		{

   684 		INFO_PRINTF1(_L("Write API did not write expected number of characters into file"));

   685 		close(fd[0]);

   686         return KErrGeneral;

   687 		}

   688 	

   689 	if((write(fd[1], "Append", 6)) != 6)

   690 		{

   691 		INFO_PRINTF1(_L("Write API did not write expected number of characters into file"));

   692 		close(fd[0]);

   693 		close(fd[1]);

   694         return KErrGeneral;

   695 		}

   696 	

   697 	close(fd[0]);

   698 	close(fd[1]);

   699 	

   700 	if((fd[0] = open(file , O_CREAT | O_RDWR , 0666))  < 0) 

   701 		{

   702 		_LIT(Kopen , "Failed to open file " ) ;

   703 		INFO_PRINTF1(Kopen) ;

   704         return KErrGeneral ;

   705 		}

   706 	

   707 	memset(Buf, 0, sizeof(Buf));

   708 	if(read(fd[0], Buf, 10) == 10) 

   709 		{

   710 		Buf[10]='\0';

   711         if(strcmp(Buf, "TestAppend"))

   712 			{

   713     		ret = KErrGeneral ;

   714 			}

   715 		else

   716 			{

   717 			ret = KErrNone;

   718 			}

   719 		}

   720 	else

   721 		{

   722 		INFO_PRINTF1(_L("read() failed"));

   723 		ret = KErrGeneral ;

   724 		}	

   725 	

   726 	close(fd[0]);

   727 	unlink(file);

   728 	return ret;

   729 	}

   730 

   731 

   732 //-------------------------------------------------------------------------------

   733 

   734 //  Test case : Write  Writes specified no of chars to the file 

   735 //            : returns 0 on success    

   736 //            : 2 on failure      

   737 //             

   738 // 

   739 //--------------------------------------------------------------------------------                  

   740 

   741 

   742 TInt CTestSyscalls :: write1()

   743 	{

   744 	int fd ;

   745 	TInt Expected ;          //Expected valued to be returned by syscall

   746 	TInt RetVal ;            //Actual value returned by syscall

   747 	TBuf8<100> string1;

   748     TPtrC String ;

   749     

   750    //first read file name , buffer and then 

   751    //actual no of bytes to be written

   752      _LIT( KString, "String" );

   753      TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   754      if(!res)   

   755 		{

   756     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   757     	INFO_PRINTF1(Kerr) ;

   758     	return KErrGeneral ;

   759 		}

   760       

   761 	string1.Copy(String);

   762 	char* file = (char*) string1.Ptr();

   763 	file[string1.Length()]='\0';

   764 	_LIT( Kwrite1, "In write1" );

   765     INFO_PRINTF1( Kwrite1 );

   766     

   767     //Read no of bytes 

   768     TInt nBytes ;

   769     _LIT( KnBytes, "nBytes" );

   770 	res = GetIntFromConfig(ConfigSection(), KnBytes, nBytes);

   771     

   772     if(!res)    

   773 		{

   774     	_LIT(Kerr , "Failed to read input number of bytes  from the inifile ") ;

   775     	INFO_PRINTF1(Kerr) ;

   776     	return KErrGeneral ; 

   777 		}

   778     

   779     //Read actual string to be written 

   780     

   781     TBuf8<100> Buf;

   782     TPtrC buff    ;

   783     

   784     _LIT( Kbuff, "buff" );

   785     res = GetStringFromConfig(ConfigSection(), Kbuff, buff);

   786     if(!res) 

   787 		{

   788     	 _LIT(Kerr , "Failed to read actual buffer form the ini file") ;

   789     	 INFO_PRINTF1(Kerr) ;

   790     	 return KErrGeneral ;

   791 		}

   792 	Buf.Copy(buff);

   793 	char* Buffer = (char*) Buf.Ptr();

   794 	Buffer[Buf.Length()]='\0';  

   795 	

   796 	

   797 	//Now read expected value 

   798 	_LIT( KExpected, "Expected" );

   799 	res = GetIntFromConfig(ConfigSection(), KExpected, Expected);

   800     unlink(file);

   801     

   802     if((fd = open(file  , O_CREAT | O_RDWR , 0666))  < 0) 

   803 		{

   804         _LIT(Kerr , "Failed to open specifed file \n") ;

   805         INFO_PRINTF1(Kerr);

   806         return KErrGeneral ;

   807 		}

   808     

   809     if((RetVal = write(fd , Buffer , nBytes) ) < 0)  

   810 		{

   811          _LIT(Kerr , "Failed to write specifed no of bytes to file ") ;

   812          INFO_PRINTF1(Kerr) ;

   813          if(nBytes > 0)

   814 			{

   815 			 close(fd);

   816 			return KErrGeneral;

   817 			}

   818 		}

   819         

   820     close(fd) ;

   821     if(RetVal == Expected)

   822 		{

   823 		return KErrNone ;

   824 		}

   825     

   826     return KErrGeneral ;

   827     

   828 	}

   829 

   830 

   831 

   832 //-------------------------------------------------------------------------------

   833 

   834 //  Test case : Writes specified no of chars to the invalid fd 

   835 //                 

   836 //             

   837 // 

   838 //--------------------------------------------------------------------------------                  

   839 

   840 

   841 TInt CTestSyscalls :: write2()

   842 	{

   843     _LIT( Kwrite2, "In write2" );

   844     INFO_PRINTF1( Kwrite2 );

   845     TInt fd ;

   846     

   847     _LIT( Kfd, "fd" );

   848 	TBool res = GetIntFromConfig(ConfigSection(), Kfd, fd);

   849     

   850     if(!res)   

   851 		{

   852     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   853     	INFO_PRINTF1(Kerr) ;

   854     	return KErrGeneral ;

   855 		}

   856     

   857     if(write(fd , "Hello" , 6) < 0)  

   858 		{

   859         if(errno == EBADF) 

   860 			{

   861            _LIT(Kok , "Invalid file descriptor passed \n") ;

   862         	INFO_PRINTF1(Kok) ;

   863         	if(write(-1 , "Hello" , 6) < 0) 

   864         		{

   865         		if(errno == EBADF) 

   866 					{

   867 					_LIT(Kok , "Invalid file descriptor passed \n") ;

   868 					INFO_PRINTF1(Kok) ;

   869         			}

   870         		else 

   871 					{

   872 					_LIT(Kerr , "failed to set errno value \n") ;

   873         			INFO_PRINTF1(Kerr) ; 

   874         			return KErrGeneral ;

   875         			}

   876         	

   877 				}

   878 			}

   879         else 

   880 			{

   881             _LIT(Kerr , "failed to set errno value \n") ;

   882         	INFO_PRINTF1(Kerr) ; 

   883         	return KErrGeneral ;

   884         	}

   885 		}

   886     return KErrNone ;

   887     }

   888 

   889 

   890 //-------------------------------------------------------------------------------

   891 

   892 //  Test case : Read in an invalid Buffer address

   893 //--------------------------------------------------------------------------------                  

   894 

   895 

   896 

   897 TInt CTestSyscalls :: write3()

   898 	{

   899  	int fd ;

   900  

   901  	TPtrC String ;

   902     TBuf8<100> string1;

   903  	

   904     _LIT( Kread3, "In write3" );

   905     INFO_PRINTF1( Kread3 );

   906   	

   907   	_LIT( KString, "String" );

   908     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   909      

   910   	if(!res) 

   911 		{

   912        _LIT(Kerr , "Failed to read the input file name from ini file") ;

   913        INFO_PRINTF1(Kerr) ;	

   914 		}

   915     

   916 	string1.Copy(String);

   917 	char* file = (char*) string1.Ptr();

   918 	file[string1.Length()]='\0';

   919 	

   920 	unlink(file);

   921   

   922   	if((fd = open(file , O_CREAT | O_RDWR , 0666))  < 0) 

   923 		{

   924        _LIT(Kerr , "Failed to open file " ) ;

   925        INFO_PRINTF1(Kerr) ;

   926         return KErrGeneral ;

   927 		}

   928     

   929     if(write(fd , NULL , 3) < 0)  

   930 		{

   931         if(errno != EFAULT)   

   932 			{

   933         	_LIT(Kerr , "Failed to set the errno value for invalid address") ;

   934         	INFO_PRINTF1(Kerr) ;

   935 			close(fd);

   936         	return KErrGeneral ;

   937 			}

   938     	

   939 		}

   940     

   941     _LIT(Kok , "Read with invalid buffer address passed") ;

   942     INFO_PRINTF1(Kok) ; 

   943     close(fd) ;

   944     return KErrNone ;

   945     

   946     

   947 	}

   948 

   949 

   950 

   951 

   952 //-------------------------------------------------------------------------------

   953 //  Test case : Write to file opened in R_ONLY MODE , 

   954 //                      

   955 //             

   956 // 

   957 //--------------------------------------------------------------------------------                  

   958 

   959 TInt CTestSyscalls :: write5()

   960 	{

   961  	int fd ;

   962 	TInt ret = KErrNone ;

   963 	TBuf8<100> string1;

   964     TPtrC String ;

   965     

   966     //Read the input file name 

   967     _LIT( KString, "String" );

   968     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   969     

   970     if(!res)   

   971 		{

   972     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

   973     	INFO_PRINTF1(Kerr) ;

   974     	return KErrGeneral ;

   975 		}

   976     

   977 	string1.Copy(String);

   978 	char* file = (char*) string1.Ptr();

   979 	file[string1.Length()]='\0';

   980 

   981     _LIT( Kwrite5, "In write5" );

   982     INFO_PRINTF1( Kwrite5 );

   983     unlink(file) ;

   984     

   985   	if((fd = open(file , O_CREAT | O_RDONLY , 0666))  < 0) 

   986 		{

   987        _LIT(Kwrite5 , "Failed to open file " ) ;

   988        INFO_PRINTF1(Kwrite5) ;

   989         return KErrGeneral ;

   990 		}

   991     

   992     if(write(fd , "Hello" , 25) < 6)  

   993 		{

   994 		int d = errno;

   995         if(errno == EBADF) 

   996 			{

   997 			ret = KErrNone ;	

   998 			}

   999     	else 

  1000     		{

  1001     		_LIT(Kerr , "Failed to set the errno value to EBADF") ;

  1002     		INFO_PRINTF1(Kerr);

  1003 			close(fd);

  1004     		ret = KErrGeneral ;

  1005     		}

  1006 		}

  1007     close(fd) ;

  1008     unlink(file) ;

  1009     return ret ;

  1010     }

  1011 

  1012 

  1013 //-------------------------------------------------------------------------------

  1014 

  1015 //  Test case : read specified bytes from a file, 

  1016 //              return 0  on success

  1017 //				3 on failure

  1018 // 

  1019 //--------------------------------------------------------------------------------                  

  1020 

  1021 

  1022 

  1023 TInt CTestSyscalls :: read1()

  1024 	{

  1025  	int fd ;

  1026  	TInt Retval ;

  1027  	char Buf[20] ;

  1028 	TBuf8<100> string1;

  1029     TPtrC String ;

  1030     

  1031     //Read the input file name 

  1032     _LIT( KString, "String" );

  1033     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

  1034     

  1035     if(!res)   

  1036 		{

  1037     	_LIT(Kerr , "Failed to read input file value from the ini file") ;

  1038     	INFO_PRINTF1(Kerr) ;

  1039     	return KErrGeneral ;

  1040 		}

  1041     

  1042 	string1.Copy(String);

  1043 	char* file = (char*) string1.Ptr();

  1044 	file[string1.Length()]='\0';

  1045 	

  1046 	TInt nbytes ;

  1047 	//read no of bytes to be read 

  1048 	

  1049 	_LIT( Knbytes, "nbytes" );

  1050 	res = GetIntFromConfig(ConfigSection(), Knbytes, nbytes);

  1051     

  1052     if(!res) 

  1053 		{

  1054 		_LIT(Kerr , "Failed to read input no of bytes to be read ") ;

  1055 		INFO_PRINTF1(Kerr) ;

  1056 		return KErrGeneral ;

  1057 		}

  1058 	

  1059 	//read Expected return value

  1060 	TInt Expected ;

  1061 	

  1062 	_LIT( KExpected, "Expected" );

  1063 	res = GetIntFromConfig(ConfigSection(), KExpected, Expected);

  1064     

  1065 	if(!res) 

  1066 		{

  1067 		_LIT(Kerr , "Failed to read input param Expected value \n") ;

  1068 		ERR_PRINTF1(Kerr);

  1069 		return KErrGeneral ;

  1070 		}

  1071     _LIT( Kread1, "In read1" );

  1072     INFO_PRINTF1( Kread1 );

  1073     unlink(file);

  1074     

  1075   	if((fd = open(file , O_CREAT | O_RDWR , 0666))  < 0) 

  1076 		{

  1077 		_LIT(Kopen , "Failed to open file " ) ;

  1078 		INFO_PRINTF1(Kopen) ;

  1079         return KErrGeneral ;

  1080 		}

  1081     

  1082     if(( write(fd , "HELLO HELLO HELLO HELLO HELLO HELLO HELLO"  , 20) )<0 ) 

  1083 		{

  1084     	_LIT(Kerr , "Failed to write to the specified file ") ;

  1085     	INFO_PRINTF1(Kerr) ;

  1086 		close(fd);

  1087     	return KErrGeneral ;

  1088 		}

  1089     close(fd) ; //open again and try to read (or do an lseek)

  1090     

  1091     

  1092   	if((fd = open(file , O_CREAT | O_RDWR , 0666))  < 0) 

  1093 		{

  1094 		_LIT(Kopen , "Failed to open file " ) ;

  1095 		INFO_PRINTF1(Kopen) ;

  1096         return KErrGeneral ;

  1097 		}

  1098     

  1099     if((Retval = read(fd , Buf , nbytes) ) < 0)  

  1100 		{

  1101     	_LIT(Kerr , "Failed to read from the specified file \n") ;

  1102 		close(fd);

  1103     	INFO_PRINTF1(Kerr);

  1104     	}

  1105     

  1106     if(Retval != Expected) 

  1107 		{

  1108     	_LIT(Kerr , "Expected and the actual return values dont match") ;

  1109     	ERR_PRINTF1(Kerr);

  1110 		close(fd);

  1111     	return KErrGeneral ;

  1112 		}

  1113     else

  1114 		{

  1115     	_LIT(Kerr , "Expected and the actual return values match") ;

  1116     	INFO_PRINTF1(Kerr);

  1117 		}

  1118    

  1119     close(fd) ;

  1120     return KErrNone ;

  1121 	}

  1122 

  1123 

  1124 //-------------------------------------------------------------------------------

  1125 

  1126 //  Test case :  Read from the given fd , no of bytes > size of file

  1127 //--------------------------------------------------------------------------------                  

  1128 

  1129 

  1130 

  1131 TInt CTestSyscalls :: read2()

  1132 	{

  1133  	int fd ;

  1134  	char Buf[20] ;