--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/openenvcore/libc/test/testsyscalls/src/tsyscallsblocks.cpp Fri Jun 04 16:20:51 2010 +0100
@@ -0,0 +1,7584 @@
+/*
+* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include "tsyscalls.h"
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <string.h>
+#include <utime.h>
+#include <time.h>
+#include <sys/wait.h>
+#include <sys/uio.h>
+#include <sys/syslimits.h>
+#include <pthread.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+
+#define CLOCKS_PER_SEC 128
+
+/*******************************************************************************
+
+ Test case : open1 creates a file Prog1.txt in cdrive
+ opens the file file in read-write mode
+
+ return : 0 on success
+
+
+*******************************************************************************/
+
+TInt CTestSyscalls :: Creat( )
+ {
+ int fd ;
+ TPtrC String ;
+ mkdir("C:\\Test" , S_IWUSR);
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file name") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ TBuf8<100> string1;
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+
+ // Print to UI
+
+ _LIT( KOpen1, "In create" );
+
+ unlink(file) ;
+ INFO_PRINTF1( KOpen1 );
+
+ if((fd = creat(file , 0666)) < 0)
+ {
+ _LIT(Kerr , "failed to open the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ return KErrNone ;
+
+ }
+
+
+/*******************************************************************************
+
+ Test case : open1 creates a file Prog1.txt in cdrive
+ opens the file file in read-write mode
+
+ return : 0 on success
+
+
+*******************************************************************************/
+
+TInt CTestSyscalls::open1( )
+ {
+ int fd ;
+ TPtrC String ;
+ TInt IsDirectory ; // This variable is used to find wheather a directory is
+ //is opened
+ TInt Expected ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file name") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ TBuf8<100> string1;
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ _LIT( KIsDirectory, "IsDirectory" );
+ res = GetIntFromConfig(ConfigSection(), KIsDirectory, IsDirectory);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read directory flag") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read directory flag") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(Expected < 0 )
+ {
+ fd = open(NULL , O_CREAT | O_RDWR , 0444) ;
+
+ if(fd < 0)
+ {
+ if(errno != EFAULT)
+ {
+ _LIT(Kerr , "Failed to set the errno value for open system call") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+ _LIT(Kerr , "open for NULL address should fail") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( KOpen1, "In open1" );
+
+ unlink(file) ;
+ INFO_PRINTF1( KOpen1 );
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ if(IsDirectory && (errno == EISDIR) )
+ {
+ _LIT(Kerrnone , "Directory open test case passes ") ;
+ INFO_PRINTF1(Kerrnone) ;
+ return KErrNone ;
+ }
+ else if(IsDirectory)
+ {
+ _LIT(Kerr , "Directory open test case fails to set err value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT(Kerr , "failed to open the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close(fd) ;
+ return KErrNone ;
+
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : open2 creates a file
+// opens in write only mode
+// return : 0 on success
+// 1 failure
+//--------------------------------------------------------------------------------
+TInt CTestSyscalls :: open2()
+ {
+ int fd ;
+ TPtrC String ;
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(res)
+ {
+ TBuf8<100> string1;
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+ _LIT( KOpen3, "In open3" );
+
+ INFO_PRINTF1( KOpen3 );
+ unlink(file);
+
+ if((fd = open(file , O_CREAT | O_WRONLY , 0666)) < 0)
+ {
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ }
+ return KErrNone ;
+
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : open3 creates a file
+// opens in readonly mode
+// return : 0 on success
+
+//--------------------------------------------------------------------------------
+TInt CTestSyscalls :: open3()
+ {
+ int fd ;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(res)
+ {
+ TBuf8<100> string1;
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ _LIT( KOpen3, "In open3" );
+ INFO_PRINTF1( KOpen3 );
+
+ unlink(file);
+ if((fd = open(file , O_RDONLY | O_CREAT , 0666)) < 0)
+ {
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ return KErrNone ;
+ }
+ else
+ {
+ return KErrGeneral;
+ }
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : open4 creates a file (Negative testcase )
+//
+// Tries to open a fails in invalid mode
+//
+// Create a file Exclusively
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: open4()
+ {
+ int fd ;
+
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , " Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+ _LIT( KOpen4, "In open4" );
+ INFO_PRINTF1( KOpen4 );
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to o given file name") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ //Now try to open the file exclusively , this open sustem call should fail
+
+ fd = open(file , O_CREAT | O_EXCL | O_RDWR , 0666) ;
+ if(fd < 0 )
+ {
+ if(errno != EEXIST)
+ {
+ _LIT(Kerr , "Failed to set errno value for open syscall") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+ _LIT(Kerr , "Failed to open a file in O_EXCL mode ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : open5 creates a file (Negative testcase )
+//
+// Tries to open a fails in invalid path
+//
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: open5()
+ {
+ int fd ;
+
+ TInt ret = KErrNone ;
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ _LIT( KOpen5, "In open5" );
+
+ INFO_PRINTF1( KOpen5 );
+ unlink(file);
+
+
+ if((fd = open(file , O_CREAT | O_RDONLY , 0666)) < 0)
+ {
+ if(errno != ENOENT)
+ {
+ _LIT(Kinvalidpath , "failed to set errno value ") ;
+ INFO_PRINTF1(Kinvalidpath);
+ ret = KErrGeneral ;
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "File opened in an invalid path test fails ") ;
+ close(fd);
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+ close(fd) ;
+ return ret ; //This ret will be set to KErrNone if all test cases are though
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : open6 truncates the file //
+//
+//
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: open6()
+ {
+ int fd ;
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ _LIT( KOpen5, "In open6" );
+ INFO_PRINTF1( KOpen5 );
+
+ unlink(file);
+
+ if((fd = open(file , O_CREAT|O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kinvalidarg , "Failed to open specified file \n") ;
+ INFO_PRINTF1(Kinvalidarg) ;
+ return KErrGeneral ;
+ }
+ if(write(fd , "hELLO" ,6) < 0)
+ {
+ _LIT(Kerr , "Failed to write to the file D:\\Prog1.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ if((fd = open(file , O_CREAT|O_RDWR|O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to tuncate the specified file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //seek and find out the size of the file
+
+ if(lseek(fd , 0 , SEEK_END) != 0 )
+ {
+ _LIT(Kerr , "file could not be truncated ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ close(fd);
+ return KErrNone ;
+
+ }
+
+/**
+ * Testcase : OpenTruncate1
+ * Description : Open a file with O_CREAT | ORDWR flag
+ * Re-open the same file with O_TRUNC
+ * stat on the file to check whether the file is trunctaed or not
+ * Return value : KErrNone
+ */
+TInt CTestSyscalls :: OpenTruncate1()
+ {
+ int fd1, fd2, ret;
+ TBuf8<128> string1;
+ TPtrC String ;
+ struct stat fInfo;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral;
+ }
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ if((fd1 = open(file, O_CREAT | O_RDWR)) < 0)
+ {
+ INFO_PRINTF2(_L("file open failed with error number %d"), errno);
+ return KErrGeneral;
+ }
+
+ if ((write(fd1, "Symbian", 7)) != 7)
+ {
+ INFO_PRINTF2(_L("write failed with error number %d"), errno);
+ close(fd1);
+ unlink(file);
+ return KErrGeneral;
+ }
+
+ // re-open the same file with O_CREAT
+ if((fd2 = open(file, O_TRUNC | O_WRONLY)) < 0)
+ {
+ INFO_PRINTF2(_L("file open with O_TRUNC failed with error number %d"), errno);
+ close(fd1);
+ unlink(file);
+ return KErrGeneral;
+ }
+
+ ret = stat(file, &fInfo);
+
+ if (ret == -1)
+ {
+ INFO_PRINTF2(_L("stat failed with error number %d"), errno);
+ close(fd1);
+ unlink(file);
+ return KErrGeneral;
+ }
+
+ if(fInfo.st_size != 0)
+ {
+ INFO_PRINTF1(_L("The file is not truncated. Testcase failed"));
+ close(fd1);
+ unlink(file);
+ return KErrGeneral;
+ }
+
+ close(fd2);
+ unlink(file);
+ return KErrNone;
+ }
+
+/**
+ * Testcase : OpenTruncate2
+ * Description : open a non existing file with flag O_TRUNC
+ * It should not create a new file
+ * Return value : KErrNone
+ */
+TInt CTestSyscalls :: OpenTruncate2()
+ {
+ int fd1, ret;
+ TBuf8<128> string1;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral;
+ }
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ if((fd1 = open(file, O_TRUNC)) < 0)
+ {
+ INFO_PRINTF1(_L("Test case passed"));
+ ret = KErrNone;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("open with only flag O_TRUNC should not creat a new file. Test case failed"));
+ close(fd1);
+ unlink(file);
+ ret = KErrGeneral;
+ }
+
+ close(fd1);
+ unlink(file);
+ return ret;
+ }
+//-----------------------------------------------------------------------------
+// Try to open a read only file in Write only mode
+
+//---------------------------------------------------------------------------
+
+TInt CTestSyscalls :: open7()
+ {
+ int fd ;
+ TInt ret = KErrNone ;
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+
+ _LIT( KOpen7 , "In open7" );
+ INFO_PRINTF1( KOpen7 );
+
+ unlink(file) ;
+
+ //First create read only file , close it and they try to
+ //open in W_ONLY mode
+
+ if((fd = open(file , O_CREAT|O_RDWR , 0444)) < 0)
+ {
+ _LIT(Kinvalidarg , "Failed to open specified file \n") ;
+ INFO_PRINTF1(Kinvalidarg) ;
+ return KErrGeneral ;
+ }
+
+ close(fd) ;
+
+ if((fd = open(file , O_CREAT|O_WRONLY ) ) < 0)
+ {
+ if(errno !=EACCES)
+ {
+ _LIT(Kerr , "Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr);
+ ret = KErrGeneral ;
+ }
+ }
+ else
+ {
+ _LIT(KErr , "Opened a read only file in Write mode hence failed ") ;
+ close(fd);
+ unlink(file);
+ INFO_PRINTF1(KErr);
+ ret = KErrGeneral ;
+ }
+
+ close(fd) ;
+ chmod(file , S_IWUSR);
+ unlink(file) ;
+ return ret ;
+
+ }
+
+
+
+/**
+* Function Name : OpenInAppendMode
+* API Tested : write
+* TestCase Description: This test case is added as part of fix for DEF114524
+* 1. A file is opened in Append mode twice
+* 2. Few bytes are written into file using two different FIDs
+* 3. File is closed using both the FIDs
+* Expected result:
+*/
+TInt CTestSyscalls::OpenInAppendMode()
+ {
+ int fd[2];
+ char Buf[10+1];
+ TInt ret = KErrNone;
+ TBuf8<100> string1;
+ TPtrC String;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+
+ if( (fd[0] = open(file, O_WRONLY | O_APPEND | O_CREAT)) < 0)
+ {
+ _LIT(KFail, "Failed to open file in append mode");
+ INFO_PRINTF1(KFail);
+ return KErrGeneral;
+ }
+
+ if((fd[1] = open(file, O_WRONLY | O_APPEND | O_CREAT)) < 0)
+ {
+ _LIT(KFail, "Failed to open file in append mode");
+ INFO_PRINTF1(KFail);
+ return KErrGeneral;
+ }
+
+ if((write(fd[0], "Test", 4)) != 4)
+ {
+ INFO_PRINTF1(_L("Write API did not write expected number of characters into file"));
+ close(fd[0]);
+ return KErrGeneral;
+ }
+
+ if((write(fd[1], "Append", 6)) != 6)
+ {
+ INFO_PRINTF1(_L("Write API did not write expected number of characters into file"));
+ close(fd[0]);
+ close(fd[1]);
+ return KErrGeneral;
+ }
+
+ close(fd[0]);
+ close(fd[1]);
+
+ if((fd[0] = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ memset(Buf, 0, sizeof(Buf));
+ if(read(fd[0], Buf, 10) == 10)
+ {
+ Buf[10]='\0';
+ if(strcmp(Buf, "TestAppend"))
+ {
+ ret = KErrGeneral ;
+ }
+ else
+ {
+ ret = KErrNone;
+ }
+ }
+ else
+ {
+ INFO_PRINTF1(_L("read() failed"));
+ ret = KErrGeneral ;
+ }
+
+ close(fd[0]);
+ unlink(file);
+ return ret;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : Write Writes specified no of chars to the file
+// : returns 0 on success
+// : 2 on failure
+//
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: write1()
+ {
+ int fd ;
+ TInt Expected ; //Expected valued to be returned by syscall
+ TInt RetVal ; //Actual value returned by syscall
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ //first read file name , buffer and then
+ //actual no of bytes to be written
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+ _LIT( Kwrite1, "In write1" );
+ INFO_PRINTF1( Kwrite1 );
+
+ //Read no of bytes
+ TInt nBytes ;
+ _LIT( KnBytes, "nBytes" );
+ res = GetIntFromConfig(ConfigSection(), KnBytes, nBytes);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input number of bytes from the inifile ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //Read actual string to be written
+
+ TBuf8<100> Buf;
+ TPtrC buff ;
+
+ _LIT( Kbuff, "buff" );
+ res = GetStringFromConfig(ConfigSection(), Kbuff, buff);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read actual buffer form the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ Buf.Copy(buff);
+ char* Buffer = (char*) Buf.Ptr();
+ Buffer[Buf.Length()]='\0';
+
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ unlink(file);
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open specifed file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+
+ if((RetVal = write(fd , Buffer , nBytes) ) < 0)
+ {
+ _LIT(Kerr , "Failed to write specifed no of bytes to file ") ;
+ INFO_PRINTF1(Kerr) ;
+ if(nBytes > 0)
+ {
+ close(fd);
+ return KErrGeneral;
+ }
+ }
+
+ close(fd) ;
+ if(RetVal == Expected)
+ {
+ return KErrNone ;
+ }
+
+ return KErrGeneral ;
+
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : Writes specified no of chars to the invalid fd
+//
+//
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: write2()
+ {
+ _LIT( Kwrite2, "In write2" );
+ INFO_PRINTF1( Kwrite2 );
+ TInt fd ;
+
+ _LIT( Kfd, "fd" );
+ TBool res = GetIntFromConfig(ConfigSection(), Kfd, fd);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(write(fd , "Hello" , 6) < 0)
+ {
+ if(errno == EBADF)
+ {
+ _LIT(Kok , "Invalid file descriptor passed \n") ;
+ INFO_PRINTF1(Kok) ;
+ if(write(-1 , "Hello" , 6) < 0)
+ {
+ if(errno == EBADF)
+ {
+ _LIT(Kok , "Invalid file descriptor passed \n") ;
+ INFO_PRINTF1(Kok) ;
+ }
+ else
+ {
+ _LIT(Kerr , "failed to set errno value \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "failed to set errno value \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : Read in an invalid Buffer address
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: write3()
+ {
+ int fd ;
+
+ TPtrC String ;
+ TBuf8<100> string1;
+
+ _LIT( Kread3, "In write3" );
+ INFO_PRINTF1( Kread3 );
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ unlink(file);
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open file " ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(write(fd , NULL , 3) < 0)
+ {
+ if(errno != EFAULT)
+ {
+ _LIT(Kerr , "Failed to set the errno value for invalid address") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(Kok , "Read with invalid buffer address passed") ;
+ INFO_PRINTF1(Kok) ;
+ close(fd) ;
+ return KErrNone ;
+
+
+ }
+
+
+
+
+//-------------------------------------------------------------------------------
+// Test case : Write to file opened in R_ONLY MODE ,
+//
+//
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: write5()
+ {
+ int fd ;
+ TInt ret = KErrNone ;
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ //Read the input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ _LIT( Kwrite5, "In write5" );
+ INFO_PRINTF1( Kwrite5 );
+ unlink(file) ;
+
+ if((fd = open(file , O_CREAT | O_RDONLY , 0666)) < 0)
+ {
+ _LIT(Kwrite5 , "Failed to open file " ) ;
+ INFO_PRINTF1(Kwrite5) ;
+ return KErrGeneral ;
+ }
+
+ if(write(fd , "Hello" , 25) < 6)
+ {
+ int d = errno;
+ if(errno == EBADF)
+ {
+ ret = KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Failed to set the errno value to EBADF") ;
+ INFO_PRINTF1(Kerr);
+ close(fd);
+ ret = KErrGeneral ;
+ }
+ }
+ close(fd) ;
+ unlink(file) ;
+ return ret ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : read specified bytes from a file,
+// return 0 on success
+// 3 on failure
+//
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: read1()
+ {
+ int fd ;
+ TInt Retval ;
+ char Buf[20] ;
+ TBuf8<100> string1;
+ TPtrC String ;
+
+ //Read the input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ TInt nbytes ;
+ //read no of bytes to be read
+
+ _LIT( Knbytes, "nbytes" );
+ res = GetIntFromConfig(ConfigSection(), Knbytes, nbytes);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input no of bytes to be read ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //read Expected return value
+ TInt Expected ;
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input param Expected value \n") ;
+ ERR_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ _LIT( Kread1, "In read1" );
+ INFO_PRINTF1( Kread1 );
+ unlink(file);
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if(( write(fd , "HELLO HELLO HELLO HELLO HELLO HELLO HELLO" , 20) )<0 )
+ {
+ _LIT(Kerr , "Failed to write to the specified file ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ close(fd) ; //open again and try to read (or do an lseek)
+
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if((Retval = read(fd , Buf , nbytes) ) < 0)
+ {
+ _LIT(Kerr , "Failed to read from the specified file \n") ;
+ close(fd);
+ INFO_PRINTF1(Kerr);
+ }
+
+ if(Retval != Expected)
+ {
+ _LIT(Kerr , "Expected and the actual return values dont match") ;
+ ERR_PRINTF1(Kerr);
+ close(fd);
+ return KErrGeneral ;
+ }
+ else
+ {
+ _LIT(Kerr , "Expected and the actual return values match") ;
+ INFO_PRINTF1(Kerr);
+ }
+
+ close(fd) ;
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : Read from the given fd , no of bytes > size of file
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: read2()
+ {
+ int fd ;
+ char Buf[20] ;
+ TInt ret = KErrNone ;
+ TBuf8<100> string1;
+ TPtrC String ;
+ _LIT( Kread2, "In read2" );
+ INFO_PRINTF1( Kread2 ) ;
+
+ //Read the input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ unlink(file);
+ if((fd = open(file , O_CREAT | O_RDWR | O_TRUNC, 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open the given file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ //write 20 bytes to the file and then try to read 30 bytes from the file
+ if( write(fd , "HELLO HELLO HELLO HELLO HELLO HELLO HELLO asdf adsf" , 20) != 20 )
+ {
+ _LIT(Kerr , "Failed to write to the specified file ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+
+ //Now reset the file pointer back to zero
+ if(lseek(fd , 0 , SEEK_SET) < 0 )
+ {
+ _LIT(Kerr , "Failed to reset the file pointer " ) ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ ret = read(fd , Buf , 30) ;
+
+ if(ret != 20)
+ {
+ _LIT(Kerr , "No of bytes returned is greater than or equal to 30 ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : Read in an invalid Buffer address
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: read3()
+ {
+ int fd ;
+ TPtrC String ;
+ TBuf8<100> string1;
+
+ _LIT( Kread3, "In read3" );
+ INFO_PRINTF1( Kread3 );
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+ unlink(file);
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open file " ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(read(fd , NULL , 3) < 0)
+ {
+ if(errno != EFAULT)
+ {
+ _LIT(Kerr , "Failed to set the errno value for invalid address") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ }
+
+ _LIT(Kok , "Read with invalid buffer address passed") ;
+ INFO_PRINTF1(Kok) ;
+ close(fd) ;
+ return KErrNone ;
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : Read from the from invalid arguments
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: read4()
+ {
+ int fd ;
+ TInt ret = KErrNone ;
+ char Buf[20] ;
+ TBuf8<50> string1;
+ TPtrC String ;
+
+ _LIT( Kread4, "In read4" );
+ INFO_PRINTF1( Kread4 );
+ if(read(-1 , Buf , 3) < 3)
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+
+ }
+
+ //Read the file name from the ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+
+ if((fd = open(file , O_CREAT | O_WRONLY , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if(read(fd , Buf , 6) < 0)
+ {
+ if(errno != EBADF)
+ {
+ _LIT(KErr , "Read from invalid fd failed \n") ;
+ INFO_PRINTF1(KErr) ;
+ close(fd);
+ ret = KErrGeneral ;
+ }
+ }
+
+ else
+ {
+ _LIT(Kerr , "Read from a write only file des should fail") ;
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+ close(fd);
+ return ret ;
+
+ }
+//-------------------------------------------------------------------------------
+
+// Test case : open a directory
+// : returns 0 on success
+// 4 on failure
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Opendir()
+ {
+ DIR *DirHandle ;
+
+ TBuf8<50> string1;
+ TPtrC String ;
+
+ TInt Expected ;
+
+ _LIT( Kopendir, "In opendir" );
+ INFO_PRINTF1( Kopendir );
+
+ //Read the directory name from the ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* directory = (char*) string1.Ptr();
+ directory[string1.Length()]='\0';
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected return value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ int status = mkdir(directory,S_IRWXU | S_IRWXG );
+
+ if (status != 0 )
+ {
+ int d = errno;
+ if (errno == EEXIST)
+ {
+ INFO_PRINTF1(_L("Directory already present")) ;
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Can't create directory"));
+ return KErrGeneral ;
+ }
+ }
+ DirHandle = opendir(directory) ;
+ if(Expected == 0) //for negative test cases
+ {
+ if(Expected != (TInt) DirHandle)
+ {
+ _LIT(Kerr , "Expected and the return values are different") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(directory);
+ return KErrGeneral ;
+ }
+ }
+ else
+ {
+ if(DirHandle == (DIR *)NULL )
+ {
+ _LIT(Kerr , "Failed to open given directory") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(directory);
+ return KErrGeneral ;
+ }
+ }
+ closedir(DirHandle);
+ rmdir(directory);
+ return KErrNone ;
+ }
+
+
+//------------------------------------------------------------------------
+//
+// test : Closedir
+//------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Closedir()
+ {
+
+ DIR *DirHandle ;
+ TBuf8<50> string1;
+ TPtrC String ;
+
+ TInt Expected ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kclosedir , "In Closedir" );
+ INFO_PRINTF1(Kclosedir);
+
+
+ //Read the directory name from the ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* directory = (char*) string1.Ptr();
+ directory[string1.Length()]='\0';
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected return value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ if(Expected < 0 )
+ {
+ closedir(NULL) ;
+
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ return KErrNone ;
+ }
+ DirHandle = opendir(directory) ;
+
+ if(DirHandle == (DIR *) NULL)
+ {
+ _LIT (Kerr , "Failed to open the directory") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(closedir(DirHandle) < 0 )
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+ return KErrNone ;
+ }
+
+
+/*
+//-------------------------------------------------------------------------------
+
+// Test case : open directory (negative test cases )
+// :
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Opendir1()
+{
+ DIR *DirHandle ;
+ char Buf[20] ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ _LIT( Kopendir, "In opendir1" );
+ INFO_PRINTF1( Kopendir );
+
+ if((DirHandle = opendir("Logs") ) != NULL)
+ {
+ _LIT( Kopendir, "Opendir for invalid argument failed" );
+ INFO_PRINTF1(Kopendir) ;
+ return KErropendir ;
+ }
+
+ if((DirHandle = opendir("C:\\testdir")) != NULL)
+ {
+ _LIT( Kopendir, "Opendir for invalid argument failed" );
+ INFO_PRINTF1(Kopendir) ;
+ return KErropendir ;
+ }
+ return KOpendir ;
+}
+*/
+
+//-------------------------------------------------------------------------------
+
+// Test case : read a directory
+// : returns 0 on success
+// 5 on failure
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Readdir()
+ {
+ DIR *DirHandle ;
+ TBuf8<50> string1;
+ TPtrC String ;
+ _LIT( Kreaddir, "In readdir" );
+ INFO_PRINTF1( Kreaddir );
+
+ //Read the directory name from the ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* directory = (char*) string1.Ptr();
+ directory[string1.Length()]='\0';
+ if((DirHandle = opendir(directory) )== NULL)
+ {
+ _LIT(Kerr , "Failed to open the given directory ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(readdir(DirHandle) == (dirent *)NULL)
+ {
+ _LIT(Kerr , " Falied to read the directory") ;
+ ERR_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ closedir(DirHandle);
+ if(readdir(DirHandle) == (dirent *)NULL && errno == EBADF)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("readir failed for invalid DIR list,Expected errno = 9 and actual errno is = %d "),errno);
+ return KErrGeneral;
+ }
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : seek to specified no of bytes in a file
+// : returns 0 on success
+// 6 on failure
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Lseek()
+ {
+ int fd ;
+ TInt Seekbytes ; //read the seek
+ TInt ret ;
+ TBuf8<50> string1;
+ TPtrC String ;
+
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ _LIT( Klseek, "In Lseek" );
+ INFO_PRINTF1(KTsyscalls) ;
+ INFO_PRINTF1( Klseek );
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+
+
+ _LIT( KSeekbytes, "Seekbytes" );
+ res = GetIntFromConfig(ConfigSection(), KSeekbytes, Seekbytes);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read seekbytes value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ unlink(file) ;
+ //SEEK AN EMPTY FILE
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ return KErrGeneral ;
+ }
+
+ ret = lseek(fd , Seekbytes ,SEEK_SET) ;
+ if(ret < 0 )
+ {
+ _LIT(Kerr , "Failed to SEEK_SET specified bytes ") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ ret = lseek(fd ,Seekbytes , SEEK_END ) ;
+
+ if(ret < 0 )
+ {
+ _LIT(Kerr , "Failed to SEEK_END specified bytes seeking beyond end of file Not supported") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ if(lseek(fd , Seekbytes , SEEK_CUR) < 0)
+ {
+ _LIT(Kerr , "Seeking beyond end of the file not supported") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ close(fd);
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : lseek test (negative tests )
+// : returns 0 on success
+// 6 on failure
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Lseek1()
+ {
+ int fd ;
+ char Buf[20] ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ _LIT( Klseek, "In Lseek" );
+ INFO_PRINTF1(KTsyscalls) ;
+ INFO_PRINTF1( Klseek );
+
+ if((fd = open("C:\\Test\\Prog1234.txt" , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ return KErrGeneral ;
+ }
+
+ if(write(fd , "HELLO HELLO hello hello" , 20) < 0)
+ {
+ _LIT(Kopen , "Failed to write to file ") ;
+ INFO_PRINTF1(Kopen) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+
+ if(lseek(fd , 2 ,SEEK_SET) < 0)
+ {
+ close(fd);
+ return KErrGeneral ;
+ }
+
+ if(read(fd , Buf , 3) > 0)
+ {
+ if(strncmp(Buf , "LLO" , 3))
+ {
+ close(fd);
+ return KErrGeneral ;
+ }
+ }
+
+ if(lseek(fd , 1 , SEEK_CUR) < 0)
+ {
+ close(fd);
+ return KErrGeneral ;
+ }
+
+ if(read(fd , Buf , 5) > 0)
+ {
+ if(strncmp(Buf , "HELLO" , 5))
+ {
+ close(fd);
+ return KErrGeneral;
+ }
+ }
+
+ //Try to seek beyond the end of file
+
+ if(lseek(fd , 10 , SEEK_END) < 0)
+ {
+ _LIT(Kseek , "seek beyond the end of file Not supported") ;
+ INFO_PRINTF1(Kseek) ;
+ }
+ //Try to seek -ve no of bytes from the start of the file
+
+ if(lseek(fd , -10 , SEEK_SET) < 0)
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kseek , "Failed to seek -ve no of bytes from starting Not supported\n") ;
+ INFO_PRINTF1(Kseek) ;
+ close(fd);
+ return KErrNone ;
+ }
+ }
+ close(fd);
+ return KErrNone ;
+ }
+
+
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : access tests R_OK for given file
+// : returns 0 on success
+// : 7 on failure
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Access()
+ {
+ int fd ;
+ TBuf8<50> string;
+ TPtrC String ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kaccess, "In Access" );
+ INFO_PRINTF1( Kaccess );
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input file name from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ unlink(file) ;
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kerr, "Failed to open the given file ") ;
+ ERR_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ if(access(file ,R_OK) != 0 )
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : access tests invalid args
+// : returns 0 on success
+// : 7 on failure
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: Access1()
+ {
+ int fd ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kaccess, "In Access" );
+ INFO_PRINTF1( Kaccess );
+ TPtrC String ;
+ TBuf8<50> string;
+ TInt ret ; //To store all the return values
+
+ ret = KErrNone ;
+
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read i/p file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ unlink(file) ;
+ if(access(file ,W_OK) < 0)
+ {
+ if(errno == ENOENT)
+ {
+ _LIT(Kaccess ,"Access test(W_OK) for a file created in Read only mode pass") ;
+ INFO_PRINTF1(Kaccess) ;
+
+ }
+ else
+ {
+ _LIT(Kaccess , "Access test failed to set errno value ") ;
+ ERR_PRINTF1(Kaccess);
+ ret = KErrGeneral ;
+ }
+ }
+ else
+ {
+ _LIT(Kaccess , "access R_OK for a non existing file failed");
+ INFO_PRINTF1(Kaccess) ;
+ ret = KErrGeneral ;
+
+ }
+
+
+ if((fd = open(file , O_CREAT | O_WRONLY , 0444)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ; ;
+ }
+ close(fd) ;
+
+ if(access(file , W_OK) < 0)
+ {
+ if(errno == EACCES)
+ {
+ _LIT(Kaccess ,"Access test(W_OK) for a file created in Read only mode pass") ;
+ INFO_PRINTF1(Kaccess) ;
+
+ }
+ else
+ {
+ ret = KErrGeneral ;
+ }
+ }
+ else
+ {
+ ret = KErrGeneral ;
+ }
+ chmod(file , S_IWUSR);
+ return ret ;
+
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : dup tests for duplicating the file descriptor
+// : returns 0 on success
+// : 8 on failure
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Dup()
+ {
+ int fd ;
+ int newfd ;
+ TPtrC String ;
+ TBuf8<50> string;
+ TInt Expected ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kdup, "In Dup" );
+ INFO_PRINTF1( Kdup);
+
+ //Read the input file name from ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read i/p file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+ unlink(file) ;
+
+ //Now read expected values
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read expected values from ini") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(Expected < 0)
+ {
+ newfd = dup(-1) ;
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(newfd != Expected)
+ {
+ _LIT(Kerr ,"Expected and the return value dont match") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+ if((fd = open(file, O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if((newfd = dup(fd)) < 0 )
+ {
+ close(fd) ;
+ unlink(file) ;
+ return KErrGeneral ;
+ }
+
+ close(fd) ;
+ close(newfd) ;
+ unlink(file) ;
+ return KErrNone ;
+
+ }
+
+
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : dup tests for duplicating the file descriptor in given slot
+// : returns 0 on success
+// : 8 on failure
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Dup2()
+ {
+ int fd ;
+ TInt newfd ;
+ TInt Expected ;
+ TInt retval ;
+ TPtrC String ;
+ TBuf8<50> string;
+
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kdup2, "In Dup2" );
+ INFO_PRINTF1( Kdup2);
+
+ //Read the input file name from ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read i/p file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+ unlink(file) ;
+
+
+ //Now read new fd's to be copied values
+ _LIT( Knewfd, "newfd" );
+ res = GetIntFromConfig(ConfigSection(), Knewfd, newfd);
+
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read New fd value from ini") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(newfd > 1000)
+ {
+ _LIT(Kerr , "Upper bound for fd not supported \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+
+ //Now read expected values
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read expected values from ini") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+
+ if((fd = open(file , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ retval = dup2(fd , newfd) ;
+
+ if(retval == Expected )
+ {
+ if(Expected < 0 )
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value of dup2 call") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ close(newfd) ;
+ return KErrNone ;
+ }
+ else
+ {
+ TInt Nbytes ;
+ //Write some thing in the new fd and find size using old fd
+ if((Nbytes = write(fd , "Hello " , 6)) < 0 )
+ {
+ _LIT(Kerr , "Failed to write through old fd ") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ struct stat buf ;
+ if(fstat(newfd , &buf ) < 0 )
+ {
+ _LIT(Kerr, "Failed to stat the file through new fd") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(Nbytes != buf.st_size)
+ {
+ _LIT(Kerr , "Failed to dupilcate the file des ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ close(newfd) ;
+ return KErrNone ;
+ }
+ }
+
+ _LIT(Kerr , "Returned and the expected values are different ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd) ;
+ close(newfd) ;
+ return KErrGeneral ;
+
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : rename tests for renaming the existing file
+// : returns 0 on success
+// : 9 on failure
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: Rename()
+ {
+ int fd ;
+ TPtrC String ;
+ TBuf8 <50> string ;
+ TInt Expected ;
+ char File1[50] ;
+ char File2[50] ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Krename, "In Rename" );
+ INFO_PRINTF1( Krename);
+
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ strcpy(File1 , file) ;
+ TPtrC theString ;
+ _LIT( KtheString, "theString" );
+ res = GetStringFromConfig(ConfigSection(), KtheString, theString );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file1 name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(theString) ;
+ file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ strcpy(File2 , file);
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ unlink(File1) ;unlink(File2);
+
+ if(Expected < 0)
+ {
+ TInt ret ;
+ ret = rename(File1 , File2) ;
+ INFO_PRINTF2(_L("errno is %d"), errno);
+ if((errno != EINVAL) && (errno != ENOENT) && (errno != EACCES))
+ {
+ _LIT(Kerr , "Failed to set errno value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(ret == Expected)
+ {
+ return KErrNone ;
+ }
+
+ _LIT(Kerr , "Expected and the returned values are not matching") ;
+ ERR_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+
+ if((fd = open(File1 , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ if(rename(File1 , File2) < 0)
+ {
+ _LIT(Krename , "Failed to rename file ") ;
+ INFO_PRINTF1(Krename) ;
+
+ return KErrGeneral ;
+ }
+
+
+ return KErrNone ;
+
+ }
+
+
+//-----------------------------------------------------------------------------
+// This function test rename call for existing files and for read-only files
+
+//------------------------------------------------------------------------------
+
+#define READ_ONLY_FILE 0
+#define NORMAL_FILE 1
+TInt CTestSyscalls :: Rename1()
+ {
+ int fd ;
+ TPtrC String ;
+ TBuf8 <50> string ;
+ TInt Command ;
+ char File1[50] ;
+ char File2[50] ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Krename, "In Rename1" );
+ INFO_PRINTF1( Krename);
+
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ strcpy(File1 , file) ;
+ TPtrC theString;
+ _LIT( KtheString, "theString" );
+ res = GetStringFromConfig(ConfigSection(), KtheString, theString );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file1 name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(theString) ;
+ file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ strcpy(File2 , file);
+
+ _LIT( KCommand, "Command" );
+ res = GetIntFromConfig(ConfigSection(), KCommand, Command);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ fd = open(File1 , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open given file1\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ switch(Command)
+ {
+ case NORMAL_FILE :
+ {
+ int fd = open(File2 , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open given file2\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close(fd) ;
+
+ if(rename(File1 , File2) < 0 )
+ {
+ _LIT(Kerr , "Rename of existing R/W file failed \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ break ;
+ }
+
+ case READ_ONLY_FILE :
+ {
+ int fd = open(File2 , O_CREAT | O_RDWR , 0444) ;
+
+ if(fd < 0)
+ {
+ _LIT(Kerr , "Failed to open given file2 \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ if(rename(File1 , File2) < 0 )
+ {
+ _LIT(Kerr , "Failed to Rename an Existing Readonly file\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ break ;
+ }
+ }
+ return KErrNone ;
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : chmod tests
+// :
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Chmod()
+ {
+ int fd ;
+ TInt Expected ;
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kchmod, "In Chmod" );
+ INFO_PRINTF1( Kchmod);
+
+ //Read input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ unlink(file) ;
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(Expected < 0 )
+ {
+
+ TInt ret1 , ret2 ;
+
+ ret1 = chmod(file , S_IWUSR) ;
+
+ if(ret1 == Expected)
+ {
+ if(errno != ENOENT)
+ {
+ _LIT(Kerr, "Failed to set errno to ENOENT") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0444) ) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ //chmod and write some thing
+ if(chmod(file , S_IWUSR) < 0)
+ {
+ _LIT(Kerr , "Failed to change the modes of the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ //file now is this file
+ // in read write mode
+ ret2 = open(file ,O_RDWR) ;
+
+ if(ret2 >= 0)
+ {
+ _LIT(Kok , "Open successfull \n") ;
+ INFO_PRINTF1(Kok);
+ close(ret2) ;
+ ret2 = -1 ;
+ }
+ unlink(file) ;
+ if((ret1 == Expected) &&(ret2 == Expected))
+ {
+ return KErrNone ;
+ }
+
+ _LIT(Kerr , "Returned and expected values are different") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ } //End of if(Expected < 0)
+
+ if(( fd = open(file , O_CREAT | O_RDWR , 0444 ))< 0 )
+ {
+ _LIT(Kerr , "Failed to open the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ if(chmod(file , S_IWUSR) <0 )
+ {
+ _LIT(Kerr , "Failed to change file mode") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ unlink(file) ;
+ return KErrNone;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : fchmod tests
+// :
+//--------------------------------------------------------------------------------
+
+
+
+TInt CTestSyscalls :: FChmod()
+{
+
+ int fd ;
+ TInt Expected ;
+ TBuf8<50> string ;
+ TPtrC String ;
+ INFO_PRINTF1(_L("FChmod Test")) ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kchmod, "In FChmod" );
+ INFO_PRINTF1( Kchmod);
+
+ //Read input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ unlink(file) ;
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ if(Expected < 0 )
+ {
+ fd = open(file , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file name for fchmod \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ TInt ret1 , ret2 ;
+
+ ret1 = fchmod(-1 , 0666) ;
+
+ if(ret1 == Expected)
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kerr, "Failed to set errno to EBADF") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+
+ }
+
+
+ //chmod and write some thing
+ if(fchmod(fd , 0444 ) < 0)
+ {
+ _LIT(Kerr , "Failed to change the modes of the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ //file now is read only and hence it cannot be opened
+ // in read write mode
+ ret2 = open(file ,O_RDWR) ;
+
+ if(ret2 < 0)
+ {
+ if(errno == EACCES)
+ {
+ _LIT (Kerr , "Read-only file and hence cannot be opened in r/w mode\n") ;
+ INFO_PRINTF1(Kerr);
+ }
+ else
+ {
+ _LIT(Kerr , "open failed to set error value ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ // return KErrNone ;
+ }
+
+ //Now try to do a chmod on closed fd
+
+ if(fchmod(fd , 0666) < 0 )
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , " fchmod failed to set errno value , for closed fd") ;
+ INFO_PRINTF1(Kerr) ;
+ close(ret2);
+ return KErrGeneral ;
+ }
+ }
+ unlink(file) ;
+
+
+ if((ret1 == Expected) &&(ret2 == Expected))
+ {
+ close(ret2);
+ return KErrNone ;
+ }
+
+ _LIT(Kerr , "Returned and expected values are different") ;
+ close(ret2);
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ } //End of if(Expected < 0)
+
+
+ if(( fd = open(file , O_CREAT | O_RDWR , 0666 ))< 0 )
+ {
+ _LIT(Kerr , "Failed to open the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //close(fd) ;
+
+
+ if(fchmod(fd , 0444) <0 )
+ {
+ _LIT(Kerr , "Failed to change file mode") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ unlink(file) ;
+ return KErrNone;
+}
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : chmod of a directory
+// : returns 0 on success
+// :
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Chmod_dir()
+ {
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kchmod, "In Chmod_dir" );
+ INFO_PRINTF1( Kchmod);
+
+ //Read input file name
+ _LIT( KString, "String");
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input directory name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *dir = (char *) string.Ptr() ;
+ dir[string.Length()] = '\0' ;
+ rmdir(dir) ; //unlink that directory
+
+ //create the directory and then change the mode of that directory
+
+ if(mkdir(dir , S_IWUSR) < 0 )
+ {
+ _LIT(Kerr , "create the directory") ;
+ ERR_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ if(chmod(dir , S_IWUSR) < 0)
+ {
+ _LIT(Kerr , "Failed to change the modes of the directory") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(dir);
+ return KErrGeneral ;
+ }
+
+ //now change the working directory to the above given directory
+
+ if(chdir(dir) < 0 )
+ {
+ if(errno != EACCES)
+ {
+ _LIT(Kerr , "Failed to set the ernno value for the chmod") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(dir);
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+ //Control comes here only for failur case
+ _LIT(Kerr , "Chdir test fails ") ;
+ rmdir(dir);
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : fchmod of a directory
+// : returns 0 on success
+// :
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: FChmod_dir()
+{
+ /*
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kchmod, "In Chmod_dir" );
+ INFO_PRINTF1( Kchmod);
+
+ //Read input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input directory name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *dir = (char *) string.Ptr() ;
+ dir[string.Length()] = '\0' ;
+ rmdir(dir) ; //unlink that directory
+
+ //create the directory and then change the mode of that directory
+
+ if(mkdir(dir , 0666) < 0 )
+ {
+ _LIT(Kerr , "create the directory") ;
+ return KErrGeneral ;
+ }
+
+ int fd = open(dir , O_RDONLY ) ;
+
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to a given directory ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(fchmod(fd , 0444) < 0)
+ {
+ _LIT(Kerr , "Failed to change the modes of the directory") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+
+ }
+
+ close(fd) ;
+ //now change the working directory to the above given directory
+
+ if(chdir(dir) < 0 )
+ {
+ if(errno != EACCES)
+ {
+ _LIT(Kerr , "Failed to set the ernno value for the chmod") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+ //Control comes here only for failur case
+ _LIT(Kerr , "Chdir test fails No support for permissions for directory ") ;
+ INFO_PRINTF1(Kerr) ;*/
+ return KErrNone ;
+
+
+}
+
+//-------------------------------------------------------------------------------
+
+// Test case : exit tests for renaming the existing file
+// : returns 0 on success
+// : 11 on failure
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Exit()
+ {
+ return KErrNone ;
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : close tests
+// : returns 0 on success
+// : 11 on failure
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Close()
+ {
+ int fd ;
+ TInt Expected ;
+ TPtrC String ;
+ TBuf8<50> string ;
+
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kclose, "In close" );
+ INFO_PRINTF1( Kclose);
+
+
+ //read the file name from ini file
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read file name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ unlink(file) ;
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(Expected < 0)
+ {
+ TInt ret1 , ret2 ;
+ TInt Err1 , Err2 ; //store the errvalues
+ //give an invalid fd
+ ret1 = close(-1) ;
+ Err1 = errno ;
+ ret2 = close(123) ;
+ Err2 = errno ;
+
+ if((ret1 == Expected) &&(ret2 == Expected))
+ {
+ if((Err1 == EBADF) && (Err2 == EBADF) )
+ {
+ return KErrNone ;
+ }
+ _LIT(Kerr , "Failed to set errno") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ else
+ {
+ _LIT(Kerr , "Expected and the return values are different ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if(close(fd) < 0)
+ {
+ _LIT(Kerr , "Failed to close the opened file") ;
+ INFO_PRINTF1(Kerr) ;
+ unlink(file) ;
+ return KErrGeneral ;
+ }
+
+ unlink(file) ;
+ return KErrNone ;
+
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : mkdir makes a directory with given name
+// : returns 0 on success
+// : 13 on failure
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Mkdir()
+ {
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt Expected , ret ; //To store expected and return values
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kmkdir, "In Mkdir" );
+ INFO_PRINTF1( Kmkdir);
+
+
+ //First read input directory name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input dir name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral;
+ }
+ string.Copy(String) ;
+
+ char *DirName = (char *)string.Ptr() ;
+
+ DirName[string.Length()] = '\0' ;
+
+ //Read Expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ rmdir(DirName) ;
+
+ ret = mkdir(DirName , S_IWUSR) ;
+
+ if(ret == Expected )
+ {
+ if(ret < 0 )
+ {
+ if((errno != ENOENT) && (errno != EEXIST))
+ {
+ _LIT(Kerr , "Failed to set errno") ;
+ ERR_PRINTF1(Kerr);
+ ret= KErrGeneral ;
+ }
+ else
+ {
+ ret = KErrNone ;
+ }
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "Expected and the return values are different ") ;
+ ERR_PRINTF1(Kerr) ;
+ ret = KErrNone ;
+ }
+ return ret;
+
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : rmdir removes the given direcorty
+// : returns 0 on success
+// : -1 on failure
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Rmdir()
+ {
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Krmdir, "In Rmdir" );
+ INFO_PRINTF1( Krmdir);
+
+ TInt Expected ;
+ TPtrC String ;
+ TBuf8<50>string ;
+ TInt ret1 , ret2 ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input dir name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *DirName = (char *) string.Ptr() ;
+ DirName[string.Length()] = '\0' ;
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input expected value ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(Expected < 0)
+ {
+ ret1 = rmdir(DirName) ;
+ if(ret1 == Expected )
+ {
+ if((errno != ENOENT) && (errno != ENOTEMPTY))
+ {
+ _LIT(Kerr , "Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "Expected and actual values are different ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //Now create a directory , create some files
+ // in the directory and then try to delete it
+
+ if(mkdir(DirName ,S_IWUSR) < 0)
+ {
+ if(errno != EEXIST)
+ {
+ _LIT(Kerr , "Failed to make dir entry") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ //Creaty an entry in the directory
+ char FullPath[50] ;
+ strcpy(FullPath , DirName) ;
+ strcat(FullPath , "\\TEST_DIR.txt") ;
+ TInt fd ;
+
+ if((fd = open(FullPath , O_CREAT | O_RDWR , 0666 ))< 0)
+ {
+ _LIT(Kerr , "Failed to create entries in the newly created dir") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ ret2 = rmdir(DirName) ;
+
+ if(ret2 == Expected)
+ {
+ TInt Ret = KErrNone ;
+ if(errno != ENOTEMPTY)
+ {
+ _LIT(Kerr , "Failed to set errno value for rmdir") ;
+ INFO_PRINTF1(Kerr) ;
+ Ret = KErrGeneral ;
+ }
+ unlink(FullPath) ;
+ rmdir(DirName) ;
+ return Ret ;
+ }
+ _LIT(Kerr , "Expected and returned values are different") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ } //End of if(Expected < 0)
+ if(mkdir(DirName ,S_IWUSR) < 0)
+ {
+ _LIT(Kerr , "Failed to make dir entry") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ ret2 = rmdir(DirName) ;
+
+ if(ret2 != Expected)
+ {
+ _LIT(KErr , "Return and expected values are different") ;
+ INFO_PRINTF1(KErr) ;
+ return KErrGeneral;
+ }
+ return KErrNone ;
+
+ }
+
+
+//For test of \.
+
+TInt CTestSyscalls :: Rmdir1()
+ {
+ if(mkdir("C:\\Test\\TestDir" ,S_IWUSR) < 0)
+ {
+ _LIT(Kerr , "Failed to make dir entry") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(rmdir("C:\\Test\\TestDir\\." ) < 0)
+ {
+ TInt Err = errno ;
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "Failed to make dir entry") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : Chdir_Rmdir removes the given direcorty
+// : returns 0 on success
+// :
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Rmdir_Chdir()
+ {
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Krmdir, "In Rmdir_Chdir" );
+ INFO_PRINTF1( Krmdir);
+
+ // TInt Expected ;
+ TPtrC String ;
+ TBuf8<50>string ;
+
+ //TInt exists = 0 ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input dir name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *DirName = (char *) string.Ptr() ;
+ DirName[string.Length()] = '\0' ;
+ //Now create a directory , create some files
+ // in the directory and then try to delete it
+ rmdir(DirName) ;
+
+ if(mkdir(DirName ,S_IWUSR) < 0)
+ {
+ if(errno != EEXIST)
+ {
+ _LIT(Kerr , "Failed to make dir entry") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+
+ //Now chage the current working directory to the new one
+ // and then try to remove that directory
+
+ if(chdir(DirName) < 0 )
+ {
+ _LIT(Kerr , "Failed to change the current working directory to the given") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //Now try to delete the current working directory.
+
+ if(rmdir(DirName) > 0 )
+ {
+ _LIT(Kerr , "Rmdir should fail as the some process is using this as currnet working directory") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+
+ }
+//-------------------------------------------------------------------------------
+
+// Test case : fsync tests
+// : returns 0 on success
+// : -1 on failure
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Fsync()
+ {
+
+ int fd ;
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt Expected ;
+ TInt ret ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ //Now read expected value
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Expected value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kfsync, "In Fsync" );
+ INFO_PRINTF1(Kfsync);
+
+ if(Expected < 0)
+ {
+ ret = fsync(-1) ;
+ if(ret != 0)
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "fsync failed") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral;
+ }
+ return KErrNone ;
+ }
+
+ if((fd = open(file , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if(fsync(fd) < 0)
+ {
+ _LIT(Kerr , "Fsync failed ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : UTIMES tests
+// : returns 0 on success
+// : 16 on failure
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Utimes()
+ {
+
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ TInt timeVal = 0;
+
+ TInt fd ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kutimes, "In Utimes" );
+ INFO_PRINTF1(Kutimes);
+
+ struct stat buf ;
+ buf.st_atime=0;
+ struct timeval tim[2] ;
+
+ fd = open("C:\\Test\\123_123.txt" , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0)
+ {
+ _LIT(Kerr , "failed to open the file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ tim[0].tv_sec = 0 ; tim[0].tv_usec = 0;
+ tim[1].tv_sec = 0 ; tim[1].tv_usec = 0;
+
+ close(fd) ;
+ //Read the input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ //Read the time
+ _LIT( KtimeVal, "timeVal" );
+ res = GetIntFromConfig(ConfigSection(), KtimeVal, timeVal);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read time value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ buf.st_atime += timeVal ;
+ if(utimes("C:\\Test\\123_123.txt" , tim) < 0 )
+ {
+
+ _LIT(Kerr, "Utime failed") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+
+
+
+ //-------------------------------------------------------------------------------
+
+// Test case : UTIMES tests
+// : returns 0 on success
+// : 16 on failure
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Utime()
+ {
+
+ TInt Expected ;
+ TInt ret ;
+ TPtrC String ;
+ TBuf8<50> string ;
+ TInt timeVal ;
+
+ struct utimbuf *tim = NULL ;
+ char *rfile ;
+ int fd = 0;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kutime, "In Utime" );
+ INFO_PRINTF1(Kutime);
+
+
+
+ //Read the input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ rfile = (char *) string.Ptr() ;
+ //Read the time
+
+ _LIT( KtimeVal, "timeVal" );
+ res = GetIntFromConfig(ConfigSection(), KtimeVal, timeVal);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read time value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ rfile[string.Length()] = '\0' ;
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Expected value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ unlink(rfile) ;
+
+
+ tim =(struct utimbuf *) calloc(1 , sizeof(struct timeval)) ;
+
+ //Negative tests
+ if(Expected < 0 )
+ {
+ tim->actime = (time_t) timeVal ;
+ tim->modtime = (time_t) timeVal ;
+
+ ret = utime(rfile , tim) ; //Try to do utime on non existent file
+
+ if(ret == Expected )
+ {
+ if(errno != ENOENT)
+ {
+ _LIT(Kerr ,"Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd) ;
+ free(tim);
+ return KErrGeneral ;
+ }
+ free(tim);
+ return KErrNone ;
+ }
+
+ } //End of if(Expected < 0)
+
+ struct stat buf1;
+
+ if((fd = open(rfile , O_CREAT | O_RDWR , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ free(tim);
+ return KErrGeneral ;
+ }
+
+
+ if(fstat(fd , &buf1) <0 )
+ {
+ _LIT(Kerr , "Failed to stat the given file ") ;
+ INFO_PRINTF1(Kerr) ;
+ free(tim);
+ return KErrGeneral ;
+ }
+
+ buf1.st_atime += timeVal ;
+ tim->actime = buf1.st_atime ;
+ tim->modtime = buf1.st_atime ;
+ // ret = utime(rfile , tim) ;
+ close(fd) ;
+
+ if(utime(rfile , tim) < 0)
+ {
+ _LIT(Kerr , "Failed to set the access and modification time stamps of the given file ") ;
+ INFO_PRINTF1(Kerr) ;
+ free(tim);
+ return KErrGeneral ;
+ }
+ free(tim);
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : CHDIR tests
+// : returns 0 on success
+// : 17(CHDIR_FAIL) on failure
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Chdir()
+ {
+
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt Expected ;
+ TInt ret ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kchdir, "In Chdir" );
+ INFO_PRINTF1(Kchdir);
+
+ //Read dir to be changed
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input dir name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *dir = (char *) string.Ptr() ;
+
+ dir[string.Length()] = '\0' ;
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Expected value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ ret = chdir(dir) ;
+
+ if(ret == Expected)
+ {
+ if(ret < 0 )
+ {
+ if(errno != ENOENT)
+ {
+ _LIT(Kerr , "Failed to set errno value ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ return KErrNone ;
+ }
+ _LIT(Kerr, "Expected and return value are different") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : FCNTL tests
+// : returns 0 on success
+// : KErrGeneral on failure
+//
+//--------------------------------------------------------------------------------
+
+#define F_BADCMD 999
+
+TInt CTestSyscalls :: Fcntl()
+ {
+
+ int fd ;
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt command ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kfcntl, "In Fcntl" );
+ INFO_PRINTF1(Kfcntl);
+ //Read file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+ //Read input command
+ _LIT( Kcommand, "command" );
+ res = GetIntFromConfig(ConfigSection(), Kcommand, command);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input command ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ remove(file);
+ if((fd = open(file , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ switch(command)
+ {
+ case F_GETFL :
+ {
+ TInt flags ;
+ flags = fcntl(fd , F_GETFL ) ;
+ if(flags != O_RDWR )
+ {
+ _LIT(Kerr , "Flag values returned is not proper ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ else
+ {
+ _LIT(Kerr , "Flags returned are correct") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ } //End of F_GETFL
+
+ case F_SETFL :
+ {
+ //First read the flag value to be set
+ TInt flag ;
+ _LIT( Kflag, "flag" );
+ res = GetIntFromConfig(ConfigSection(), Kflag, flag);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input flag value to be set ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(fcntl(fd , F_SETFL , O_APPEND) < 0 )
+ {
+ _LIT(Kerr , "Failed to set the flags of the opened file \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if((flag = fcntl(fd , F_GETFL)) != (O_RDWR | O_APPEND))
+ {
+ _LIT(Kerr , "fcntl for F_SETFL Failed") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ } //End of F_SETFL
+
+
+ case F_DUPFD : //Duplicate file descriptor
+ {
+ TInt Newfd ;
+ Newfd = fcntl(fd , F_DUPFD ,fd -1) ;
+ if(Newfd < (fd - 1 ))
+ {
+ _LIT(Kerr , "failed to duplicate file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(Newfd);
+ Newfd = fcntl(fd , F_DUPFD , fd ) ;
+ close (Newfd);
+ if(Newfd < fd )
+ {
+ _LIT(Kerr , "failed to duplicate file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(Newfd);
+ Newfd = fcntl(fd , F_DUPFD , fd+1 ) ;
+ //Write something in using new file descriptor
+ if(Newfd < (fd +1 ))
+ {
+ _LIT(Kerr , "failed to duplicate file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ int nbytes ;
+ if((nbytes = write(Newfd , "Hello" , 6)) < 0 )
+ {
+ _LIT(Kerr , "dup value returned is improper " ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //Now find out the size of the file through old fd
+
+ struct stat buf ;
+
+ if(fstat(fd , &buf) < 0 )
+ {
+ _LIT(Kerr , "Failed to stat the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(buf.st_size != nbytes)
+ {
+ _LIT(Kerr , "File des are not duplicated properly") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+ close(Newfd);
+ break ;
+ } //End of F_DUPFL
+
+ case F_GETFD : //get close on exec flags
+ {
+ TInt cflag ;
+
+ cflag = fcntl(fd , F_GETFD ) ;
+
+ if(cflag < 0 )
+ {
+ _LIT(Kerr , "failed to get close on exec flags") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ break ;
+ } //End of F_GETFD
+
+ case F_SETFD : //Set close on exec flags
+ {
+ //First read the flag value to be set
+ TInt flag ;
+ _LIT( Kflag, "flag" );
+ res = GetIntFromConfig(ConfigSection(), Kflag, flag);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input flag value to be set ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(fcntl(fd , F_SETFD , flag) < 0 )
+ {
+ _LIT(Kerr , "Failed to set the flags of the opened file \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ break ;
+ } //End of F_SETFD
+
+ case F_BADCMD :
+ {
+ if(fcntl(fd , F_BADCMD , 1) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "Fcntl failed to set errno value for bad command") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT(Kok , "Fcntl test passes for bad command");
+ INFO_PRINTF1(Kok) ;
+ return KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Fcntl should fail for bad command but passes") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ } //End of F_BADCMD :
+ case F_SETLK :
+ {
+ TInt flag,start,len,whence;
+ //First read the flag value to be set
+ _LIT( Kflag, "flag" );
+ res = GetIntFromConfig(ConfigSection(), Kflag, flag);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the flag ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT( Kstart, "start" );
+ res = GetIntFromConfig(ConfigSection(), Kstart, start);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read start ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT( Klen, "len" );
+ res = GetIntFromConfig(ConfigSection(), Klen, len);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the len ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ _LIT( Kwhence, "whence" );
+ res = GetIntFromConfig(ConfigSection(), Kwhence, whence);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the whence ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ struct flock fl;
+ fl.l_type = F_WRLCK;
+ fl.l_whence = whence;
+ fl.l_start = start;
+ fl.l_len = len;
+ for(int i=0;i<=15;i++)
+ {
+ if(write(fd , "hello" ,6) < 0)
+ {
+ _LIT(Kerr , "Failed to write to the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ _LIT(Kerr1 , "errno%d") ;
+ INFO_PRINTF2(Kerr1,errno) ;
+ close(fd) ;
+ return KErrGeneral ;
+ }
+ }
+
+
+ if(flag==1||flag==2||flag==3||flag==4||flag==11)
+ {
+ if(fcntl(fd , F_SETLK , &fl)== -1 )
+ {
+ _LIT(Kerr , "Failed to set the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ if (errno == EACCES || errno == EAGAIN)
+ {
+ _LIT(Kerr , "Failed to set the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+
+ }
+ if(flag==5||flag==9||flag==12)
+ {
+ if(fcntl(fd , F_SETLK , &fl)!= -1 )
+ {
+ _LIT(Kerr , " set the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+ if(flag==6)
+ {
+ if(fcntl(-1 , F_SETLK , &fl)!= -1 )
+ {
+ _LIT(Kerr , " set the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+ if(flag==7)
+ {
+ if(fcntl(fd , F_SETLK , NULL)!= -1 )
+ {
+ _LIT(Kerr , " set the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+
+ if(flag==10)
+ {
+ fl.l_type = F_RDLCK;
+ if(fcntl(fd , F_SETLK , &fl)!= -1 )
+ {
+ return KErrGeneral ;
+ }
+ }
+
+ break ;
+ } //End of F_SETLK
+
+ case F_GETLK :
+ {
+
+ TInt flag,start,len,whence;
+ //First read the flag value to be set
+ _LIT( Kflag, "flag" );
+ res = GetIntFromConfig(ConfigSection(), Kflag, flag);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the flag ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT( Kstart, "start" );
+ res = GetIntFromConfig(ConfigSection(), Kstart, start);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the start ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT( Klen, "len" );
+ res = GetIntFromConfig(ConfigSection(), Klen, len);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the len ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ _LIT( Kwhence, "whence" );
+ res = GetIntFromConfig(ConfigSection(), Kwhence, whence);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the whence") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ for(int i=0;i<=15;i++)
+ {
+ if(write(fd , "hello" ,6) < 0)
+ {
+ _LIT(Kerr , "Failed to write to the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ _LIT(Kerr1 , "errno%d") ;
+ INFO_PRINTF2(Kerr1,errno) ;
+ close(fd) ;
+ return KErrGeneral ;
+ }
+ }
+
+ struct flock fl;
+ fl.l_type = F_WRLCK;
+ fl.l_whence = whence;
+ fl.l_start = start;
+ fl.l_len = len;
+ if(flag==8)
+ {
+ if(fcntl(fd , F_GETLK , &fl)== -1 )
+ {
+ _LIT(Kerr , "Failed to get the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ fl.l_type = F_WRLCK;
+ fl.l_whence = whence;
+ fl.l_start = start;
+ fl.l_len = len;
+ if(fcntl(fd , F_GETLK , &fl)!= -1 )
+ {
+ _LIT(Kerr , "Failed to get the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+ if(flag==1||flag==3||flag==4||flag==5)
+ {
+ if(fcntl(fd , F_GETLK , &fl)== -1 )
+ {
+ _LIT(Kerr , "Failed to get the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ if (errno == EACCES || errno == EAGAIN)
+ {
+ _LIT(Kerr , "Failed to get the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ if( fl.l_type != F_UNLCK)
+ {
+ return KErrGeneral;
+ }
+ }
+
+ if(flag==6||flag==2)
+ {
+ if(fcntl(fd , F_GETLK , &fl)!= -1 )
+ {
+ _LIT(Kerr , "Failed to get the lock on the opened file \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+ if(flag==7)
+ {
+ fl.l_type = F_RDLCK;
+ if(fcntl(fd , F_GETLK , &fl)!= -1 )
+ {
+ return KErrGeneral ;
+ }
+ }
+
+ break ;
+ } //End of F_GETFL
+ default :
+ {
+ _LIT(Kerr , "Invalid command ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ } //End of default
+ }
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------
+
+// Test case : ioctl tests
+// : returns 0 on success
+// : 18(KErrFcntl) on failure
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Ioctl()
+ {
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt command ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kfcntl, "In Fcntl" );
+ INFO_PRINTF1(Kfcntl);
+
+
+ //Read file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ //Read input command
+ _LIT( Kcommand, "command" );
+ res = GetIntFromConfig(ConfigSection(), Kcommand, command);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read the input command ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if((open(file , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to create file ") ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ switch(command)
+ {
+ default :
+ {
+ _LIT(Kerr , "Invalid command ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ } //End of default
+ }
+ }
+
+#define SIZE 0
+#define LINKS 1
+#define ATIME 2
+#define MTIME 3
+#define CTIME 4
+
+
+TInt CTestSyscalls :: Fstat()
+ {
+ int fd ;
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt Expected ;
+ TInt command ;
+ TInt ret =KErrNone;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kfstat, "In Fstat" );
+ INFO_PRINTF1(Kfstat);
+ //Read dir to be changed
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Expected value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //Now read command
+ _LIT( Kcommand, "command" );
+ res = GetIntFromConfig(ConfigSection(), Kcommand, command);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read command value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(Expected < 0 )
+ {
+ struct stat statbuf ;
+ fd = -1 ;
+ ret = fstat(fd , &statbuf) ;
+ if(ret == Expected)
+ {
+ if(errno !=EBADF)
+ {
+ _LIT(Kerr , "Failed to set errno value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Return and expected values are different") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+
+ unlink(file) ;
+
+ if((fd = open(file , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open specified file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //Write some bytes to the file
+
+ if(write(fd , "Hello Hello" , 12 ) < 12)
+ {
+ _LIT(Kerr , "failed to write to the newly opened file ") ;
+ ERR_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ struct stat Buf ;
+ Buf.st_atime = -1 ; //Need to do some modifications here
+ Buf.st_mtime = -1 ;
+ Buf.st_ctime = -1 ;
+
+ if(fstat(fd , &Buf) < 0)
+ {
+ _LIT(Kerr , "Failed to fstat the given file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ switch(command)
+ {
+ case SIZE :
+ if(12 == Buf.st_size)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+
+ case ATIME :
+ if(Buf.st_atime > 0)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+
+ case MTIME :
+ if(Buf.st_mtime > 0)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+
+ case CTIME : //This will be same as atime. DEF124164
+ if(Buf.st_ctime > 0)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+ }
+ close (fd) ;
+ unlink(file);
+
+ if(ret != Expected )
+ {
+ _LIT(Kerr , "Expected and return values dont match") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+}
+
+#define NORMAL_FILE_NAME "c:\\Test\\stattestnormal.txt"
+#define HIDDEN_SYS_FILE_NAME "c:\\Test\\stattesthidden.txt"
+#define HIDDEN_FILE 0
+#define SYSTEM_FILE 1
+
+//---------------------------------------------------------------------------
+//Stat Test cases
+//---------------------------------------------------------------------------
+TInt CTestSyscalls :: Stat1()
+{
+ struct stat normalStat = {0};
+ struct stat hiddenSysStat = {0};
+ TInt Expected ;
+ TInt command ;
+ TBool res ;
+ RFs rfs;
+
+ TInt err = rfs.Connect();
+
+ _LIT(KNormalFileName, "c:\\Test\\stattestnormal.txt");
+ _LIT(KHiddenSysFileName, "c:\\Test\\stattesthidden.txt");
+
+ // Create files for testing
+ if (err == KErrNone)
+ {
+ RFile normalFile;
+ RFile hiddenFile;
+ err = normalFile.Create(rfs, KNormalFileName, EFileWrite);
+ if(KErrNone != err)
+ {
+ rfs.Delete(KNormalFileName);
+ err = normalFile.Create(rfs, KNormalFileName, EFileWrite);
+ }
+
+ if (err == KErrNone)
+ {
+ normalFile.Close();
+ err = hiddenFile.Create(rfs, KHiddenSysFileName, EFileWrite);
+ if(KErrNone != err)
+ {
+ rfs.Delete(KHiddenSysFileName);
+ err = hiddenFile.Create(rfs, KHiddenSysFileName, EFileWrite);
+ }
+ if (err == KErrNone)
+ {
+ hiddenFile.Close();
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Expected value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //Now read command
+ _LIT( Kcommand, "command" );
+ res = GetIntFromConfig(ConfigSection(), Kcommand, command);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read command value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ switch(command)
+ {
+ case HIDDEN_FILE:
+ rfs.SetAtt(KHiddenSysFileName, KEntryAttHidden, 0);
+ break;
+ case SYSTEM_FILE:
+ rfs.SetAtt(KHiddenSysFileName, KEntryAttSystem, 0);
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "Failed to Connect to FileServer ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ // Do the stat for files
+ if (err == KErrNone)
+ {
+ stat(NORMAL_FILE_NAME, &normalStat);
+ stat(HIDDEN_SYS_FILE_NAME, &hiddenSysStat);
+
+ // Stat should be equivalent for both, since hidden attribute should not be relevant for statting,
+ // and especially it shouldn't mean that the file is a symbolic link.
+ if (normalStat.st_mode == hiddenSysStat.st_mode)
+ {
+ _LIT(Kerr , "st_modes are equivalent!") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ else
+ {
+ _LIT(Kerr , "st_modes are different!") ;
+ INFO_PRINTF1(Kerr) ;
+ err = KErrGeneral;
+ }
+
+ if ((hiddenSysStat.st_mode & S_IFLNK) == S_IFLNK)
+ {
+ _LIT(Kerr , "Hidden file considered a symbolic link!!") ;
+ INFO_PRINTF1(Kerr) ;
+ err = KErrGeneral;
+ }
+ }
+
+ //rfs.Delete(KNormalFileName);
+ //rfs.Delete(KHiddenSysFileName);
+ rfs.Close();
+
+ return err;
+}
+
+
+//---------------------------------------------------------------------------
+//Stat Test cases
+//---------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Stat()
+ {
+ int fd ;
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt Expected ;
+ TInt command ;
+ TInt ret=KErrNone ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kfstat, "In stat" );
+ INFO_PRINTF1(Kfstat);
+
+ //Read dir to be changed
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Expected value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //Now read command
+ _LIT( Kcommand, "command" );
+ res = GetIntFromConfig(ConfigSection(), Kcommand, command);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read command value from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(Expected < 0 )
+ {
+ struct stat statbuf ;
+ unlink(file) ;
+ ret = stat(file , &statbuf) ;
+
+ if(ret == Expected)
+ {
+ if(errno !=ENOENT)
+ {
+ _LIT(Kerr , "Failed to set errno value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Return and expected values are different") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ unlink(file) ;
+
+ if((fd = open(file , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open specified file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //Write some bytes to the file
+
+ if(write(fd , "Hello Hello" , 12 ) < 12)
+ {
+ _LIT(Kerr , "failed to write to the newly opened file ") ;
+ ERR_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd);
+
+ struct stat Buf ;
+ Buf.st_atime = -1 ;
+ Buf.st_atime = -1 ; //Need to do some modifications here
+ Buf.st_mtime = -1 ;
+ Buf.st_ctime = -1 ;
+
+ if(stat(file , &Buf) < 0)
+ {
+ _LIT(Kerr , "Failed to fstat the given file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ switch(command)
+ {
+ case SIZE :
+ if(12 == Buf.st_size)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+
+ case ATIME :
+ if(Buf.st_atime > 0)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+
+ case MTIME :
+ if(Buf.st_mtime > 0)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+
+ case CTIME : //This will be same as atime. DEF124164
+ if(Buf.st_ctime > 0)
+ {
+ ret = 0 ;
+ }
+ else
+ {
+ ret = -1 ;
+ }
+ break ;
+ }
+ close (fd) ;
+ unlink(file);
+
+ if(ret != Expected )
+ {
+ _LIT(Kerr , "Expected and return values dont match") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+
+ }
+
+
+//---------------------------------------------------------------------------
+//Stat Test cases
+//---------------------------------------------------------------------------
+TInt CTestSyscalls :: Stat2()
+ {
+ TInt ret = KErrNone;
+
+ _LIT(Kerr , "stat should not succeed for nonexistent drives!") ;
+ INFO_PRINTF1(Kerr) ;
+
+ RFs rfs;
+ ret = rfs.Connect();
+ if(KErrNone == ret)
+ {
+ TDriveList aList;
+ TUint16 driveNum = 0;
+ char buffer[4];
+ char buffer2[20];
+ struct stat st;
+
+ rfs.DriveList(aList);
+
+ for(char c='A'; c <='Z'; c++, driveNum++, ret = KErrNone)
+ {
+ sprintf(buffer, "%c:/", c);
+ sprintf(buffer2, "%c:/private/", c);
+
+ ret = stat(buffer, &st);
+ if((0 != aList[driveNum]) && (KErrNone != ret))
+ {
+ ERR_PRINTF2(_L("stat Failed for an existing drive : %c "),c);
+ return KErrGeneral ;
+ }
+ ret = stat(buffer2, &st);
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "Failed to Connect to FileServer ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone;
+ }
+
+
+//-------------------------------------------------------------------------
+// getpid test :
+//-------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Getpid()
+ {
+ pid_t pid ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kgetpid, "In Getpid" );
+ INFO_PRINTF1(Kgetpid);
+
+ pid = getpid() ;
+
+ if(pid < 0 )
+ {
+ _LIT(Kerr , "getpid call failed \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------
+// Time test :
+//-------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Time()
+ {
+
+ time_t tim;
+ char Buff[50] ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Ktime , "In Time" );
+ INFO_PRINTF1(Ktime);
+
+ if(time(&tim) < 0 )
+ {
+ _LIT(Kerr , "time call failed \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ char* ptr = ctime(&tim);
+ strcpy(Buff , ctime(&tim)) ; //For Debug testing
+
+ return KErrNone ;
+
+ }
+
+
+//-------------------------------------------------------------------------
+// Clock test :
+//-------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Clock()
+ {
+
+ clock_t tim;
+ char Buff[50] ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Ktime , "In Clock" );
+ INFO_PRINTF1(Ktime);
+
+ tim = clock() ;
+
+ if(tim == (clock_t)-1 )
+ {
+ _LIT(Kerr , "clock call failed \n") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ strcpy(Buff , ctime((const int *)&tim)) ; //For Debug testing
+
+ return KErrNone ;
+
+ }
+
+
+//-------------------------------------------------------------------------
+// Waitpid test :
+//-------------------------------------------------------------------------
+
+TInt CTestSyscalls :: WaitPid()
+ {
+ pid_t pid ;
+ TInt status ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kwaitpid , "WaitPid" );
+ INFO_PRINTF1(Kwaitpid);
+
+ pid = getpid() ;
+
+ if(pid < 0 )
+ {
+ _LIT(Kerr , "Failed to get pid ") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+
+ if(waitpid(pid , &status , 0) < 0 )
+ {
+ if(errno != ECHILD)
+ {
+ _LIT(Kerr , " failed to set errno value for waitpid") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+ return KErrNone ;
+ }
+
+TInt CTestSyscalls :: Sleep()
+ {
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Ksleep , "Sleep" );
+ INFO_PRINTF1(Ksleep);
+ TInt Stime ; //sleep time
+ _LIT( KStime, "Stime" );
+ TBool res = GetIntFromConfig(ConfigSection(), KStime, Stime);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read Sleep time from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ sleep(Stime);
+ return KErrNone ;
+ }
+
+/*
+//------------------------------------------------------------------
+//Waitpid test : wait on a dead child
+//-------------------------------------------------------------------
+TInt CTestSyscalls :: WaitPid1()
+{
+
+ pid_t pid ;
+ TInt status ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kwaitpid , "WaitPid" );
+ INFO_PRINTF1(Kwaitpid);
+
+ pid = getpid() ;
+
+ if(pid < 0 )
+ {
+ _LIT(Kerr , "Failed to get pid ") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+
+ if(waitpid(pid , &status , 0) < 0 )
+ {
+ if(errno != ECHILD)
+ {
+ _LIT(Kerr , " failed to set errno value for waitpid") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+ return KErrNone ;
+}
+
+*/
+
+/*
+*This function test writev for directory file discrptor
+*/
+
+TInt CTestSyscalls :: Writev_Dir_Test(char *file)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+ int fd =open(file , O_RDONLY) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given directory for readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(writev(fd , Iovec , 2) < 0 )
+ {
+
+ if(errno != EBADF)
+ {
+ _LIT(Kerr , "failed to set errno value for writev for directory file discriport") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Write on a directory file discriptor should fail ");
+ INFO_PRINTF1(Kerr) ;
+ }
+ return KErrGeneral ;
+ }
+
+/**
+*This function test writev on an invalid file discriptor
+**/
+
+TInt CTestSyscalls :: Writev_Invalid_Fd(void)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+
+ if(writev(-1 , Iovec , 2) < 0 )
+ {
+ if(errno == EBADF)
+ {
+ _LIT(Kok , "writev from invalid discrptor passed") ;
+ INFO_PRINTF1(Kok) ;
+ return KErrNone ;
+ }
+ _LIT(Kerr , "writev failed to set errno value to EBADF") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT(Kerr , "writev from an invalid discriptor should fail but found to pass" ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+/**
+* This function is called by Writev() and tests writev on an
+* read-only file discriptor
+**/
+
+TInt CTestSyscalls :: Writev_Readfd_Test(char *file )
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_WRONLY | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EACCES )
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ return KErrNone ;
+ }
+
+
+//-------------------------------------------------------------------------------------------------
+// This function test for writev with iov vector length as zero
+// and is called by
+//-------------------------------------------------------------------------------------------------
+TInt CTestSyscalls :: Writev_Invalidcount_Test(char *file , TInt Firstarg)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ if(Firstarg)
+ {
+ Iovec[0].iov_len = 0 ;
+ Iovec[1].iov_len = 20 ;
+ }
+ else
+ {
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_len = 0 ;
+ }
+
+ Iovec[0].iov_base = Buf1;
+ Iovec[1].iov_base = Buf2 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file writev test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(writev(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "failed to write from different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ }
+ close(fd);
+ return KErrNone ;
+ }
+
+/**
+* This function is called by writev and is used to test writev for
+* invalid io- vector addresses
+**/
+
+TInt CTestSyscalls :: Writev_AddInvalid_Test(char *file ,TInt Firstarg)
+ {
+ char Buf1[20] = "HELLO";
+ char Buf2[20] = "World" ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ if(Firstarg)
+ {
+ Iovec[0].iov_base = NULL ;
+ Iovec[1].iov_base = Buf2 ;
+ }
+ else
+ {
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[1].iov_base = NULL ;
+ }
+
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_len = 20 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(writev(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "failed to write from different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ return KErrNone ;
+ }
+
+/**
+* This function is called by WriteV() function and tests writev call
+* for io-vectors = IOV_MAX.
+**/
+
+TInt CTestSyscalls :: Writev_MaxIov_Test(char *file)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ TInt fd = 0 ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(writev(fd , Iovec , IOV_MAX + 1) < 0 )
+ {
+ if(errno == EINVAL)
+ {
+ _LIT(Kok , "INVALID ARGUMENT PASSED") ;
+ INFO_PRINTF1(Kok) ;
+ return KErrNone ;
+ }
+ _LIT(Kerr , "readv failed to set errno value to EBADF") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT(Kerr , "readv from an invalid discriptor should fail but found to pass" ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+/**
+ *This function is called by WriteV() function and this function test writev
+ * for negative io-vector lengths
+**/
+
+TInt CTestSyscalls :: Writev_Negativecount_Test(char *file , TInt Firstarg)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ if(Firstarg)
+ {
+ Iovec[0].iov_len = 0 ;
+ Iovec[1].iov_len = size_t(-123 );
+ }
+ else
+ {
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_len = size_t(-12) ;
+ }
+
+ Iovec[0].iov_base = Buf1;
+ Iovec[1].iov_base = Buf2 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(writev(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ close(fd);
+ return KErrGeneral ;
+ }
+ }
+ close(fd);
+ return KErrNone ;
+
+ }
+
+/**
+* This function is called by WriteV and does functionality testing of writev
+* system call.
+**/
+
+TInt CTestSyscalls :: Writev_Normal(char *file)
+ {
+ char Buf1[] = "Hello World";
+ char Buf2[] = "By ritche" ;
+ struct iovec Iovec[2] ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = sizeof(Buf1) ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = sizeof(Buf2) ;
+
+ TInt fd = open(file , O_CREAT | O_RDWR | O_TRUNC , 0666) ;
+
+ if(fd < 0)
+ {
+ _LIT(Kerr , "failed to open the given file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(writev(fd , Iovec , 2) < (sizeof(Buf1) + sizeof(Buf2)) )
+ {
+ _LIT(Kerr , "Failed to write given no of bytes to the file specified") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+
+ }
+
+/**
+* This function is called by ReadV() function and does functionality test
+* of readv System call.
+**/
+
+TInt CTestSyscalls :: Readv_Normal(char *file)
+ {
+ char Buf1[20] ; //= "Hello World";
+ char Buf2[20] ; //= "By ritche" ;
+ struct iovec Iovec[2] ;
+ TInt ret=KErrNone;
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = sizeof("Hello World") ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = sizeof("By ritche") ;
+
+ TInt fd = open(file , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0)
+ {
+ _LIT(Kerr , "failed to open the given file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ _LIT(Kerr , "Failed to read from the file specified") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if((!strcmp(Buf1 , "Hello World")) && (!strcmp(Buf2 , "By ritche")))
+ {
+ _LIT(Kok , "Readv normal test case pass") ;
+ INFO_PRINTF1(Kok) ;
+ ret = KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr, "Failed to read from the file") ;
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+ return ret;
+
+ }
+
+TInt CTestSyscalls :: Readv_Dir_Test(char *file)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+ int fd =open(file , O_RDONLY) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given directory for readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ return KErrNone ;
+ }
+
+TInt CTestSyscalls :: Readv_Invalid_Fd(void)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+
+ if(readv(-1 , Iovec , 2) < 0 )
+ {
+
+ if(errno == EBADF)
+ {
+ _LIT(Kok , "readv from invalid discrptor passed") ;
+ INFO_PRINTF1(Kok) ;
+ return KErrNone ;
+ }
+ _LIT(Kerr , "readv failed to set errno value to EBADF") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT(Kerr , "readv from an invalid discriptor should fail but found to pass" ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+TInt CTestSyscalls :: Readv_Writefd_Test(char *file )
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_WRONLY | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EBADF )
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ return KErrNone ;
+ }
+
+
+TInt CTestSyscalls :: Readv_AddInvalid_Test(char *file ,TInt Firstarg)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ if(Firstarg)
+ {
+ Iovec[0].iov_base = NULL ;
+ Iovec[1].iov_base = Buf2 ;
+ }
+ else
+ {
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[1].iov_base = NULL ;
+ }
+
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_len = 20 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+
+ return KErrNone ;
+
+ }
+
+
+
+
+
+/**
+* This function test for readv for vector length = IOV_MAX
+**/
+
+
+TInt CTestSyscalls :: Readv_MaxIov_Test(char *file)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ TInt fd = 0 ;
+
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = 20 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ if(readv(fd , Iovec , IOV_MAX + 1) < 0 )
+ {
+ if(errno == EINVAL)
+ {
+ _LIT(Kok , "INVALID ARGUMENT PASSED") ;
+ INFO_PRINTF1(Kok) ;
+ return KErrNone ;
+ }
+ _LIT(Kerr , "readv failed to set errno value to EBADF") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ _LIT(Kerr , "readv from an invalid discriptor should fail but found to pass" ) ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+
+ }
+
+/**
+This function test for readv with iov vector length as negative
+**/
+TInt CTestSyscalls :: Readv_Invalidcount_Test(char *file , TInt Firstarg)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ if(Firstarg)
+ {
+ Iovec[0].iov_len = 0 ;
+ Iovec[1].iov_len = 20 ;
+ }
+ else
+ {
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_len = 0 ;
+ }
+
+ Iovec[0].iov_base = Buf1;
+ Iovec[1].iov_base = Buf2 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+
+ return KErrNone ;
+ }
+
+
+TInt CTestSyscalls :: Readv_Negativecount_Test(char *file , TInt Firstarg)
+ {
+ char Buf1[20] ;
+ char Buf2[20] ;
+ struct iovec Iovec[2] ;
+ int fd = 0 ;
+
+ if(Firstarg)
+ {
+ Iovec[0].iov_len = 0 ;
+ Iovec[1].iov_len = size_t(-123) ;
+ }
+ else
+ {
+ Iovec[0].iov_len = 20 ;
+ Iovec[1].iov_len = size_t(-12) ;
+ }
+
+ Iovec[0].iov_base = Buf1;
+ Iovec[1].iov_base = Buf2 ;
+
+ unlink(file) ;
+
+ fd = open(file , O_RDWR | O_CREAT , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open the given file readv test") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(readv(fd , Iovec , 2) < 0 )
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr , "failed to read to different I/O Vectors for directory file descriptor") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ return KErrNone ;
+
+ }
+
+
+#define DIRECT_TEST 0 //test for directory
+#define INVALID_ADD_TEST 1 //test for invalid address
+#define INVALID_FD 2 //test for invalid file descriptor
+#define WRITE_ONLY_FD 3 // test of read on write only fd
+#define INVALID_COUNT_TEST 4 //Test for invalid vector count
+#define MAX_IOV_MAX 5 //TEST if the iovector is > IOV_MAX
+#define COUNT_NEGATIVE 7 //negative count testing
+#define REGULAR_TEST 8 //functionality test
+#define READ_ONLY_FD 9 //Test for read-only fd for writev
+
+TInt CTestSyscalls :: ReadV()
+ {
+ TInt cmd = 0 ;
+ TBuf8<50> string ;
+ TPtrC String ;
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+ _LIT( Kcmd, "cmd" );
+ res = GetIntFromConfig(ConfigSection(), Kcmd, cmd);
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ TInt retVal = 0 ;
+
+ switch(cmd)
+ {
+
+ case DIRECT_TEST :
+ retVal = Readv_Dir_Test(file) ;
+ break ;
+
+ case INVALID_FD :
+ retVal = Readv_Invalid_Fd() ;
+ break ;
+
+ case WRITE_ONLY_FD :
+ retVal = Readv_Writefd_Test(file ) ;
+ break ;
+
+ case INVALID_COUNT_TEST :
+ {
+ TInt retVal1 = Readv_Invalidcount_Test(file , 1) ;
+ TInt retVal2 = Readv_Invalidcount_Test(file , 0) ;
+
+ if((retVal1 != 0 ) && (retVal2 != 0))
+ {
+ retVal = KErrGeneral ;
+ }
+ else
+ {
+ retVal = KErrNone ;
+ }
+ break ;
+ }
+ case INVALID_ADD_TEST :
+ {
+ TInt retVal1 = Readv_AddInvalid_Test(file , 1) ;
+ TInt retVal2 = Readv_AddInvalid_Test(file , 0) ;
+
+ if((retVal1 != 0 ) && (retVal2 != 0))
+ {
+ retVal = KErrGeneral ;
+ }
+ else
+ {
+ retVal = KErrNone ;
+ }
+ break ;
+ }
+
+ case MAX_IOV_MAX :
+ {
+ retVal = Readv_MaxIov_Test(file) ;
+ break;
+ }
+
+ case COUNT_NEGATIVE:
+ {
+ TInt retVal1 = Readv_Negativecount_Test(file , 0) ;
+ TInt retVal2 = Readv_Negativecount_Test(file , 0) ;
+
+ if((retVal1 != 0 ) && (retVal2 != 0))
+ {
+ retVal = KErrGeneral ;
+ }
+ else
+ {
+ retVal = KErrNone ;
+ }
+ break ;
+ }
+
+ case REGULAR_TEST :
+ {
+ unlink(file) ;
+ Writev_Normal(file) ;
+ retVal = Readv_Normal(file);
+ unlink(file) ;
+ break ;
+ }
+
+ } //End of switch
+ return retVal ;
+
+ }
+
+
+/**
+This function tests the writev api
+**/
+
+TInt CTestSyscalls :: WriteV()
+ {
+
+ TInt cmd = 0 ;
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+ _LIT( Kcmd, "cmd" );
+ res = GetIntFromConfig(ConfigSection(), Kcmd, cmd);
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ TInt retVal = 0 ;
+
+ switch(cmd)
+ {
+
+ case DIRECT_TEST :
+ retVal = Writev_Dir_Test(file) ;
+ break ;
+
+ case INVALID_FD :
+ retVal = Writev_Invalid_Fd() ;
+ break ;
+
+ case READ_ONLY_FD :
+ retVal = Writev_Readfd_Test(file ) ;
+ break ;
+
+ case INVALID_COUNT_TEST :
+ {
+ TInt retVal1 = Writev_Invalidcount_Test(file , 1) ;
+ TInt retVal2 = Writev_Invalidcount_Test(file , 0) ;
+
+ if((retVal1 != 0 ) && (retVal2 != 0))
+ {
+ retVal = KErrGeneral ;
+ }
+ else
+ {
+ retVal = KErrNone ;
+ }
+ break ;
+ }
+ case INVALID_ADD_TEST :
+ {
+ TInt retVal1 = Writev_AddInvalid_Test(file , 1) ;
+ TInt retVal2 = Writev_AddInvalid_Test(file , 0) ;
+
+ if((retVal1 != 0 ) && (retVal2 != 0))
+ {
+ retVal = KErrGeneral ;
+ }
+ else
+ {
+ retVal = KErrNone ;
+ }
+ break ;
+ }
+
+ case MAX_IOV_MAX :
+ {
+ retVal = Writev_MaxIov_Test(file) ;
+ break;
+ }
+
+ case COUNT_NEGATIVE:
+ {
+ TInt retVal1 = Writev_Negativecount_Test(file , 0) ;
+ TInt retVal2 = Writev_Negativecount_Test(file , 0) ;
+
+ if((retVal1 != 0 ) && (retVal2 != 0))
+ {
+ retVal = KErrGeneral ;
+ }
+ else
+ {
+ retVal = KErrNone ;
+ }
+ break ;
+ }
+
+ case REGULAR_TEST :
+ {
+ Writev_Normal(file) ;
+ retVal = Readv_Normal(file);
+ unlink(file) ;
+ break ;
+ }
+
+ } //End of switch
+ return retVal ;
+
+ }
+
+TInt CTestSyscalls :: SeekDir()
+ {
+ TInt Expected = 0 ;
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to Expected value from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ char file1[100] = { 0 } ;
+ char file2[100] = { 0 } ;
+ char file3[100] = { 0 } ;
+
+ strcpy(file1 , file) ;
+ strcat(file1 , "Test_seek1.txt") ;
+ strcpy(file2 , file) ;
+ strcat(file2 , "Test_seek2.txt") ;
+ strcpy(file3 , file) ;
+ strcat(file3 , "Test_seek3.txt") ;
+
+ unlink(file1) ;
+ unlink(file2) ;
+ unlink(file3) ;
+ rmdir(file) ;
+
+ if(mkdir(file , 0777) < 0 )
+ {
+
+ _LIT(Kerr , "Failed to create the given directory %d") ;
+ int n = errno;
+ INFO_PRINTF2(Kerr,n) ;
+ return KErrGeneral ;
+ }
+
+
+ int fd = open(file1 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek1.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ fd = open(file2 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek2.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+
+ fd = open(file3 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek3.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ if(Expected < 0 )
+ {
+ DIR *Handle = opendir (file) ;
+ if(!Handle)
+ {
+ _LIT(Kerr , "Failed to open directory ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ seekdir(Handle , telldir(Handle) -1 ) ;
+
+ struct dirent *Dir ;
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kok , "invalid seek \n") ;
+ INFO_PRINTF1(Kok) ;
+ }
+ else
+ {
+ _LIT(Kerr , "read from from invalid handle \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ rewinddir(Handle ) ;
+ seekdir(Handle , telldir(Handle) + 2) ;
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kerr , "Failed to read from the directory.") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kok , "illegal seek.") ;
+ INFO_PRINTF1(Kok) ;
+ }
+
+ rewinddir(Handle) ;
+ seekdir(Handle , telldir(Handle) + 1) ;
+
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kerr , "Failed to read from the directory..") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kerr , "Failed to read from the directory... ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kok , "Failed to read from the directory.... ") ;
+ INFO_PRINTF1(Kok) ;
+ }
+
+ rewinddir(Handle) ;
+ seekdir(Handle , telldir(Handle) + 0 ) ;
+
+ Dir = readdir(Handle);
+ if(!Dir)
+ {
+ _LIT(Kerr , "Failed to read from the directory..... ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ Dir = readdir(Handle);
+ if(!(Dir))
+ {
+ _LIT(Kerr , "Failed to read from the directory...... ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ Dir = readdir(Handle);
+ if(!(Dir))
+ {
+ _LIT(Kerr , "Failed to read from the directory....... ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ Dir = readdir(Handle);
+ if(!(Dir))
+ {
+ _LIT(Kok , "illegal seek.") ;
+ INFO_PRINTF1(Kok) ;
+ }
+ rewinddir(Handle) ;
+
+ seekdir(Handle , telldir(Handle) + 4) ;
+ Dir = readdir(Handle);
+ if(!(Dir))
+ {
+ _LIT(Kok , "illegal seek.") ;
+ INFO_PRINTF1(Kok) ;
+ }
+ closedir(Handle) ;
+ }
+
+ DIR *Handle ;
+ //struct dirent *Dir ;
+
+ if ((Handle = opendir(file)) == NULL)
+ {
+ _LIT(Kerr , "Failed to open given directory %d\n") ;
+ int n = errno;
+ INFO_PRINTF2(Kerr, n) ;
+ return KErrGeneral ;
+ }
+
+ int count = 0 ;
+
+ while(/*Dir =*/ readdir(Handle))
+ {
+ count++ ;
+ }
+
+ if(count != 3)
+ {
+ _LIT(Kerr , "Actual entries and read entries differ \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ closedir(Handle);
+ return KErrNone ;
+}
+
+TInt CTestSyscalls :: RewindDir()
+ {
+
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT(Kinfo , "In RewindDir") ;
+ INFO_PRINTF1(Kinfo) ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+ char file1[100] = { 0 } ;
+ char file2[100] = { 0 } ;
+ char file3[100] = { 0 } ;
+
+ strcpy(file1 , file) ;
+ strcat(file1 , "\\Test_seek1.txt") ;
+ strcpy(file2 , file) ;
+ strcat(file2 , "\\Test_seek2.txt") ;
+ strcpy(file3 , file) ;
+ strcat(file3 , "\\Test_seek3.txt") ;
+
+ unlink(file1) ; unlink(file2) ; unlink(file3) ; rmdir(file) ;
+
+ if(mkdir(file , 0777) < 0 )
+ {
+
+ _LIT(Kerr , "Failed to create the given directory") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ int fd = open(file1 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek1.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ fd = open(file2 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek2.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ DIR *Handle = opendir(file) ;
+
+ if(!Handle)
+ {
+ _LIT(Kerr , "Failed to open the directory ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ int count = 0 ;
+
+ while(/*Dir = */readdir(Handle))
+ {
+ count++ ;
+ }
+
+ if(count != 2)
+ {
+ _LIT(Kerr , "expected and returned no of directory entries are different.") ;
+ INFO_PRINTF1(Kerr) ;
+ closedir(Handle);
+ return KErrGeneral ;
+ }
+
+ fd = open(file3 , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0 )
+ {
+
+ _LIT(Kerr , "Failed to open final file ") ;
+ INFO_PRINTF1(Kerr) ;
+ closedir(Handle);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ rewinddir(Handle) ;
+ count = 0 ;
+
+ while(/*Dir =*/ readdir(Handle))
+ {
+ count++ ;
+ }
+
+ if(count != 3)
+ {
+ _LIT(Kerr , "expected and returned no of directory entries are different..") ;
+ INFO_PRINTF1(Kerr) ;
+ closedir(Handle);
+ return KErrGeneral ;
+ }
+ closedir(Handle);
+ return KErrNone ;
+ }
+
+TInt CTestSyscalls :: Telldir()
+ {
+
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT(Kinfo , "In RewindDir") ;
+ INFO_PRINTF1(Kinfo) ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr, "Failed to read input file name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+
+ file[string.Length()] = '\0' ;
+
+
+
+ char file1[100] = { 0 } ;
+ char file2[100] = { 0 } ;
+ char file3[100] = { 0 } ;
+
+ strcpy(file1 , file) ;
+ strcat(file1 , "\\Test_seek1.txt") ;
+ strcpy(file2 , file) ;
+ strcat(file2 , "\\Test_seek2.txt") ;
+ strcpy(file3 , file) ;
+ strcat(file3 , "\\Test_seek3.txt") ;
+
+ unlink(file1) ;
+ unlink(file2) ;
+ unlink(file3) ;
+ rmdir(file) ;
+
+ if(mkdir(file , 0777) < 0 )
+ {
+
+ _LIT(Kerr , "Failed to create the given directory") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+
+ int fd = open(file1 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek1.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ fd = open(file2 , O_CREAT | O_RDWR , 0777) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "failed to open create file Test_seek2.txt") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ close (fd) ;
+
+ DIR *Handle = opendir(file) ;
+
+ if(!Handle)
+ {
+ _LIT(Kerr , "Failed to open the directory ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ int count = 0 ;
+
+ do
+ {
+ if(count != telldir(Handle))
+ {
+ _LIT(Kerr , "value returned from telldir is not same as expected.");
+ INFO_PRINTF1(Kerr) ;
+ closedir(Handle);
+ return KErrGeneral ;
+ }
+
+ count++ ;
+ } while(/*Dir = */readdir(Handle)) ;
+
+
+
+ fd = open(file3 , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0 )
+ {
+ _LIT(Kerr , "Failed to open final file ") ;
+ INFO_PRINTF1(Kerr) ;
+ closedir(Handle);
+ return KErrGeneral ;
+ }
+ close(fd) ;
+
+ rewinddir(Handle) ;
+ count = 0 ;
+
+ while(/*Dir = */readdir(Handle))
+ {
+ count++ ;
+ if(count != telldir(Handle))
+ {
+ _LIT(Kerr , "value returned from telldir is not same as expected.");
+ INFO_PRINTF1(Kerr) ;
+ closedir(Handle);
+ return KErrGeneral ;
+ }
+ }
+ closedir(Handle);
+ return KErrNone ;
+ }
+
+TInt CTestSyscalls ::TestClock()
+ {
+ TInt n;
+ INFO_PRINTF1(_L("Starting countdown...\n"));
+ for (n=10; n>0; n--)
+ {
+ //printf ("%d\n",n);
+ clock_t endwait;
+ endwait = clock () + 1 * CLOCKS_PER_SEC ;
+ while (clock() < endwait) {}
+ }
+ INFO_PRINTF1(_L("1 sec delay!!\n"));
+ return 0;
+ }
+
+TInt CTestSyscalls :: Creat2( ) // negative test case so on errr conditions returning KErrNone
+ {
+ int fd ;
+ char mbcbuf[64] = {'\0'};
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ TPtrC8 outbufstring((TText8*)mbcbuf, strlen(mbcbuf));
+ TBuf16<100> outbufname;
+ outbufname.Copy(outbufstring);
+ INFO_PRINTF2(_L("mbcbuf : %S"), &outbufname);
+ if((fd = creat(mbcbuf, 0666)) < 0)
+ {
+ _LIT(Kstmt , "creat success") ;
+ INFO_PRINTF1(Kstmt) ;
+ close(fd) ;
+ return KErrNone;
+ }
+
+
+ _LIT(Kstmt , "creat failure") ;
+ INFO_PRINTF1(Kstmt) ;
+ INFO_PRINTF2(_L("The errno set is %d\n"),errno);
+ return KErrGeneral;
+ }
+TInt CTestSyscalls :: open8() // negative test case so on errr conditions returning KErrNone
+ {
+ int fd ;
+ char mbcbuf[64]= {'\0'};
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ INFO_PRINTF2(_L("The errno set is %s\n"),mbcbuf);
+ if((fd = open(mbcbuf, O_CREAT|O_RDWR , 0444)) < 0)
+ {
+ _LIT(Kstmt , "open success") ;
+ INFO_PRINTF1(Kstmt) ;
+ close(fd) ;
+ return KErrNone;
+ }
+ _LIT(Kstmt , "open failure") ;
+ INFO_PRINTF2(_L("The errno set is %d\n"),errno);
+ INFO_PRINTF1(Kstmt) ;
+ return KErrGeneral;
+
+ }
+
+TInt CTestSyscalls :: TestStat()
+ {
+ int ret=KErrNone;
+ struct stat buf;
+ char *path = "C:\\private\\1028308C";
+
+ ret = stat(path, &buf);
+
+ if (!ret)
+ {
+ if(S_ISDIR(buf.st_mode))
+ {
+ _LIT(KSuccess, "Success");
+ INFO_PRINTF1(KSuccess);
+
+ int count=0;
+ DIR *handle = opendir(path);
+
+ if (handle == NULL)
+ {
+ INFO_PRINTF1(_L("Failed to open directory"));
+ }
+
+ while(readdir(handle))
+ {
+ count++;
+ }
+
+ closedir(handle);
+
+ }
+ else if(S_ISREG(buf.st_mode))
+ {
+ INFO_PRINTF1(_L("Its a file"));
+ }
+
+ }
+ else
+ {
+ _LIT(KFailure, "Failure in STAT");
+ INFO_PRINTF1(KFailure);
+ }
+
+ return ret;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : -ve test for lseek() on tty console
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Lseekttytest1()
+ {
+ TInt res ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ _LIT( Klseek, "In Lseek for stderr" );
+ INFO_PRINTF1(KTsyscalls) ;
+ INFO_PRINTF1( Klseek );
+ res = lseek(2, 0, SEEK_CUR) ;
+ if(res < 0 )
+ {
+ _LIT(Kerr , "lseek always fails on tty") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : -ve test for lseek() on tty console
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Lseekttytest2()
+ {
+ TInt res ;
+ _LIT( KTsyscalls, "Tsyscalls" );
+ _LIT( Klseek, "In Lseek for stdout" );
+ INFO_PRINTF1(KTsyscalls) ;
+ INFO_PRINTF1( Klseek );
+ res = lseek(1, 0, SEEK_CUR) ;
+ if(res < 0 )
+ {
+ _LIT(Kerr , "lseek always fails on tty") ;
+ INFO_PRINTF1(Kerr) ;
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------
+// Test case : -ve test for waitpid()
+//-------------------------------------------------------------------------
+
+TInt CTestSyscalls :: WaitPidtest()
+ {
+ TInt status ;
+ TInt ret;
+ _LIT( KTsyscalls1, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls1) ;
+ _LIT( Kwaitpid1 , "WaitPid" );
+ INFO_PRINTF1(Kwaitpid1);
+ ret = waitpid(-1 , &status , WUNTRACED);
+ if (ret < 0)
+ {
+ _LIT( Kwaitinfo , "negative test for waitpid()" );
+ INFO_PRINTF1(Kwaitinfo);
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------
+// Test case : -ve test for wait()
+//-------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Waittest()
+ {
+ TInt status ;
+ TInt ret;
+ _LIT( KTsyscalls1, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls1) ;
+ _LIT( Kwait1 , "Wait" );
+ INFO_PRINTF1(Kwait1);
+ ret = wait(&status);
+ if (ret < 0)
+ {
+ _LIT( Kwaitinfo , "negative test for wait()" );
+ INFO_PRINTF1(Kwaitinfo);
+ }
+ return KErrNone ;
+ }
+
+
+ /*-----------------------------------------------------------------
+ *Test Case:To Check 256 open file descriptor is supported
+ *-----------------------------------------------------------------
+ */
+
+ TInt CTestSyscalls :: Open_FileDes_Test()
+ {
+ int fd[253];
+ TPtrC String ;
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(res)
+ {
+ TBuf8<100> string1;
+ string1.Copy(String);
+ char* file = (char*) string1.Ptr();
+ file[string1.Length()]='\0';
+ _LIT( KOpen3, "In open3" );
+ INFO_PRINTF1( KOpen3 );
+ unlink(file);
+ for(TInt i=0;i<253;i++)
+ {
+ fd[i] = open(file ,O_CREAT | O_WRONLY , 0666);
+ if(fd[i]<0)
+ {
+ _LIT( KFailedinfo, "Failed to create and open file in current working directory" );
+ INFO_PRINTF1(KFailedinfo);
+ return KErrGeneral;
+ }
+ }
+ for(int i=0;i<253;i++)
+ {
+ close(fd[i]);
+ }
+ }
+ return KErrNone ;
+ }
+
+TInt CTestSyscalls :: openuid()
+ {
+ TInt openret,ret;
+
+ ret = mkdir ("c:\\private\\1028308c",S_IRWXU| S_IRWXG);
+ _LIT( KTsyscalls2, "MKDIR passed %d " );
+ INFO_PRINTF2(KTsyscalls2,ret);
+ openret = open("c:\\Private\\1028308c\\name1_1028308c.db", O_RDWR|O_CREAT|O_BINARY|0, 0600);
+
+ if(openret == -1)
+ {
+ _LIT( KTsyscalls1, "open failed" );
+ INFO_PRINTF1(KTsyscalls1);
+ return KErrGeneral;
+ }
+ _LIT( KTsyscalls1, "open passed" );
+ INFO_PRINTF1(KTsyscalls1);
+ close(openret);
+
+ return KErrNone;
+ }
+//-------------------------------------------------------------------------------
+
+// Test case : MkDir1 - Tests wheather the mkdir sets the Errno EEXIST for the
+// path c:\\private\\<UID3>
+// : returns 0 on success
+// :
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Mkdir1()
+ {
+ TInt ret1,ret2;
+
+ ret1 = mkdir ("c:\\private\\1028308c",S_IRWXU| S_IRWXG);
+
+ if(ret1 == 0)
+ {
+ ret2 = mkdir ("c:\\private\\1028308c",S_IRWXU| S_IRWXG);
+ _LIT( KTsyscalls2, "mkdir returned %d" );
+ INFO_PRINTF2(KTsyscalls2,ret2);
+ if(ret2==-1 && errno == EEXIST)
+ {
+ _LIT( KTsyscalls1, "mkdir passed" );
+ INFO_PRINTF1(KTsyscalls1);
+ return KErrNone;
+ }
+ }
+ else if(ret1 ==-1 && errno == EEXIST)
+ {
+ _LIT( KTsyscalls3, "mkdir returned %d and set the proper error code" );
+ INFO_PRINTF2(KTsyscalls3,ret1);
+ return KErrNone;
+ }
+ _LIT( KTsyscalls1, "mkdir failed" );
+ INFO_PRINTF1(KTsyscalls1);
+
+ return KErrGeneral;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : MkDir2 - Tests wheather the mkdir sets the Errno EEXIST for the
+// path c:\\private\\<UID3>\\directory
+// : returns 0 on success
+// :
+//
+//--------------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Mkdir2()
+ {
+ TInt ret1,ret2;
+
+ ret1 = mkdir ("c:\\private\\1028308c\\testcase",S_IRWXU| S_IRWXG);
+
+ if(ret1 == 0)
+ {
+ ret2 = mkdir ("c:\\private\\1028308c\\testcase",S_IRWXU| S_IRWXG);
+ _LIT( KTsyscalls2, "mkdir returned %d" );
+ INFO_PRINTF2(KTsyscalls2,ret2);
+ if(ret2==-1 && errno == EEXIST)
+ {
+ _LIT( KTsyscalls1, "mkdir passed" );
+ INFO_PRINTF1(KTsyscalls1);
+ return KErrNone;
+ }
+ }
+ else if(ret1 ==-1 && errno == EEXIST)
+ {
+ _LIT( KTsyscalls3, "mkdir returned %d and set the proper error code" );
+ INFO_PRINTF2(KTsyscalls3,ret1);
+ return KErrNone;
+ }
+ _LIT( KTsyscalls1, "mkdir failed" );
+ INFO_PRINTF1(KTsyscalls1);
+
+ return KErrGeneral;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : Chmod for Others and group
+// : Negative Test case
+// :
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Chmod1()
+ {
+ TInt Expected ,Mode ;
+ TBuf8<50> string ;
+ TPtrC String ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kchmod, "In Chmod1" );
+ INFO_PRINTF1( Kchmod);
+
+ //Read input file name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ unlink(file) ;
+
+ //To read flag bit to be set
+ _LIT( KMode, "Mode" );
+ res = GetIntFromConfig(ConfigSection(), KMode, Mode );
+ _LIT(Kerr,"mode value is %d\n");
+ INFO_PRINTF2(Kerr,Mode) ;
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read the file mode bit from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ //Now read expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(Expected < 0 )
+ {
+ TInt ret1;
+ ret1 = chmod(file , Mode) ;
+ if(ret1 == Expected)
+ {
+ if(errno != EINVAL)
+ {
+ _LIT(Kerr, "Failed to set errno to EINVAL") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ }
+ _LIT(KMsg,"Chmod success");
+ INFO_PRINTF1(KMsg) ;
+ return KErrNone;
+ }
+
+ //-----------------------------------------------------------------------------
+// This function test rename call for directories
+
+//------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Rename2()
+ {
+ int fd ;
+ TPtrC String ;
+ TBuf8 <50> string ;
+ TInt HasFiles ;
+ char File1[50] ;
+ char File2[50] ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Krename, "In Rename2" );
+ INFO_PRINTF1( Krename);
+
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(String) ;
+ char *file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ strcpy(File1 , file) ;
+ TPtrC theString;
+ _LIT( KtheString, "theString" );
+ res = GetStringFromConfig(ConfigSection(), KtheString, theString );
+ if(!res)
+ {
+ _LIT(Kerr , "failed to read input file1 name ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ string.Copy(theString) ;
+ file = (char *) string.Ptr() ;
+ file[string.Length()] = '\0' ;
+
+ strcpy(File2 , file);
+
+ _LIT( KHasFiles, "HasFiles" );
+ res = GetIntFromConfig(ConfigSection(), KHasFiles, HasFiles);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ switch(HasFiles)
+ {
+ case 0 :
+ {
+ /*Rename empty directory*/
+ res = mkdir(File1,0666);
+ if(res < 0 )
+ {
+ _LIT(Kerr , "Failed to create directory1\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(rename(File1 , File2) < 0 )
+ {
+ _LIT(Kerr , "Rename of directory failed \n") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(File1);
+ return KErrGeneral ;
+ }
+ rmdir(File2);
+ break ;
+ }
+
+ case 1:
+ {
+ /* Rename a non empty directory*/
+ res = mkdir(File1,0666);
+ if(res < 0 )
+ {
+ _LIT(Kerr , "Failed to create directory1\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ chdir(File1);
+ fd = open("./abc.txt" , O_CREAT | O_RDWR , 0666) ;
+ if(fd < 0)
+ {
+ _LIT(Kerr , "Failed to open given file2 \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd);
+ chdir("..");
+ if(rename(File1 , File2) < 0 )
+ {
+ _LIT(Kerr , "Failed to Rename\n") ;
+ printf("%d",errno);
+ INFO_PRINTF1(Kerr) ;
+ chdir(File1);
+ if(unlink("./abc.txt") < 0)
+ {
+ _LIT(Kerr , "Failed to unlinkfile2 \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ rmdir(File2);
+ return KErrGeneral ;
+ }
+ chdir(File2);
+ unlink("./abc.txt") ;
+ chdir("..");
+ rmdir(File2);
+ break ;
+ }
+ case 2:
+ {
+ /* Try to rename to an nonempty destination*/
+ res = mkdir(File1,0666);
+ if(res < 0 )
+ {
+ _LIT(Kerr , "Failed to create directory1\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ res = mkdir(File2,0666);
+ if(res < 0 )
+ {
+ _LIT(Kerr , "Failed to create directory\n") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(File1);
+ return KErrGeneral ;
+ }
+ chdir(File1);
+ fd = open("./abc.txt" , O_CREAT | O_RDWR , 0666) ;
+ if(fd < 0)
+ {
+ _LIT(Kerr , "Failed to open given file2 \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd);
+ chdir(File2);
+ fd = open("./abc.txt" , O_CREAT | O_RDWR , 0666) ;
+ if(fd < 0)
+ {
+ _LIT(Kerr , "Failed to open given file2 \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd);
+ if(rename(File1 , File2) == 0 )
+ {
+ _LIT(Kerr , "Test Case Failed\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ chdir(File1);
+ unlink("./abc.txt");
+ chdir(File2);
+ rmdir(File1);
+ unlink("./abc.txt");
+ chdir("..");
+ rmdir(File2);
+ break;
+ }
+ case 3:
+ {
+ /* Try to rename to an nonempty destination*/
+ res = mkdir(File1,0666);
+ if(res < 0 )
+ {
+ _LIT(Kerr , "Failed to create directory1\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ res = mkdir(File2,0666);
+ if(res < 0 )
+ {
+ _LIT(Kerr , "Failed to create directory\n") ;
+ INFO_PRINTF1(Kerr) ;
+ rmdir(File1);
+ return KErrGeneral ;
+ }
+ chdir(File1);
+ fd = open("./abc.txt" , O_CREAT | O_RDWR , 0666) ;
+ if(fd < 0)
+ {
+ _LIT(Kerr , "Failed to open given file2 \n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ close(fd);
+ if(rename(File1 , File2) < 0 )
+ {
+ _LIT(Kerr , "Test Case Failed\n") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ chdir(File2);
+ unlink("./abc.txt");
+ chdir("..");
+ rmdir(File2);
+ break;
+ }
+ }
+ return KErrNone ;
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : mkdir makes a directory and checks with the expected value
+// : returns 0 on success
+//
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Mk_dir()
+ {
+ TBuf8<50> string ;
+ TPtrC String ;
+ TInt Expected , ret , Expected_Errno; //To store expected and return values
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kmkdir, "In Mk_dir" );
+ INFO_PRINTF1( Kmkdir);
+
+
+ //First read input directory name
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input dir name from ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral;
+ }
+ string.Copy(String) ;
+
+ char *DirName = (char *)string.Ptr() ;
+
+ DirName[string.Length()] = '\0' ;
+
+ //Read Expected value
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ //errno Expected value
+ _LIT( KExpected_Errno, "Expected_Errno" );
+ res = GetIntFromConfig(ConfigSection(), KExpected_Errno, Expected_Errno);
+
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read expected errno value from the ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ rmdir(DirName) ;
+
+ ret = mkdir(DirName , S_IWUSR) ;
+
+ if(ret == Expected )
+ {
+ if(errno == Expected_Errno)
+ {
+ _LIT(KSuccess, "Success in setting the errno value");
+ INFO_PRINTF1(KSuccess);
+ return KErrNone;
+ }
+ else
+ {
+ _LIT(KErr,"Failure in setting the errno value");
+ INFO_PRINTF1(KErr);
+ return KErrGeneral;
+ }
+ }
+ else
+ {
+ _LIT(KError,"Error in returning the value");
+ INFO_PRINTF1(KError);
+ return KErrGeneral;
+ }
+ }
+
+//-------------------------------------------------------------------------------
+
+// Test case : rm_dir removes the given direcorty and checks with the expected value
+// Contains both positive and negative test cases
+// : returns 0 on success
+// : -1 on failure
+//
+//--------------------------------------------------------------------------------
+
+TInt CTestSyscalls :: Rm_dir()
+ {
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Krm_dir, "In Rm_dir" );
+ INFO_PRINTF1( Krm_dir);
+
+ TInt Expected , Expected_Errno ;
+ TPtrC String ;
+ TBuf8<50>string ;
+ TInt ret1 ;
+
+ _LIT( KString, "String" );
+ TBool res = GetStringFromConfig(ConfigSection(), KString, String );
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input dir name from ini file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ string.Copy(String) ;
+
+ char *DirName = (char *) string.Ptr() ;
+ DirName[string.Length()] = '\0' ;
+
+ _LIT( KExpected, "Expected" );
+ res = GetIntFromConfig(ConfigSection(), KExpected, Expected);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input expected value ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+
+ _LIT( KExpected_Errno, "Expected_Errno" );
+ res = GetIntFromConfig(ConfigSection(), KExpected_Errno, Expected_Errno);
+ if(!res)
+ {
+ _LIT(Kerr , "Failed to read input expected value ini file") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ if(Expected_Errno == 20)
+ {
+ int fd = open(DirName,O_WRONLY|O_CREAT);
+ if(fd == -1)
+ {
+ _LIT(KErr,"failed to create a file and the errno is %d");
+ INFO_PRINTF2(KErr,errno);
+ return KErrGeneral;
+ }
+ }
+ if(Expected < 0)
+ {
+ //negative test case
+ ret1 = rmdir(DirName) ;
+ if(ret1 == Expected )
+ {
+ if(errno == Expected_Errno)
+ {
+ _LIT(Kmsg , "rmdir successfully passed") ;
+ INFO_PRINTF1(Kmsg);
+ return KErrNone;
+ }
+ else
+ {
+ _LIT(Kerr , "Failed to set errno value") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ else
+ {
+ _LIT(Kerr , "Expected and actual values are different ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ else
+ {
+ //to check only pass scenerio of rmdir
+ mkdir(DirName,S_IWUSR);
+ ret1 = rmdir(DirName);
+ if(ret1 == 0)
+ {
+ _LIT(Kmsg1,"positive case of rmdir is success");
+ INFO_PRINTF1(Kmsg1);
+ return KErrNone;
+ }
+ else
+ {
+ _LIT(Kerr1,"failed to delete the directory");
+ INFO_PRINTF1(Kerr1);
+ return KErrGeneral;
+ }
+ }
+ }
+
+/*
+ * Test case to verify the thread safety of the lseek & fsync api when the file is buffered.
+ */
+
+int fd;
+
+void* handler(void *)
+ {
+ int ret;
+ ret = fsync(fd);
+ ret = ret;
+ return 0;
+ }
+
+
+void* handler1(void *)
+ {
+ int ret;
+ lseek(fd, 2, SEEK_SET);
+ ret = fsync(fd); //only one fsync should be able to sync the data.
+ ret = ret;
+ return 0;
+ }
+
+TInt CTestSyscalls :: sync_safe()
+ {
+ int fd1,ret;
+ char buf[5];
+ pthread_t thread_a, thread_b;
+ unlink("c:\\readfrom.txt");
+ unlink("c:\\writeto.txt");
+ fd1 = open("c:\\readfrom.txt", O_RDWR | O_CREAT, 0666);
+ write(fd1,"hello",5);
+ lseek(fd1,0,SEEK_SET);
+ fd = open("c:\\writeto.txt",O_RDWR | O_CREAT | O_BUFFERED);
+ ret = read(fd1, buf, sizeof(buf));
+ ret = write(fd,buf,sizeof(buf));
+ pthread_create (&thread_a, 0 , handler, 0);
+ pthread_create (&thread_b, 0 , handler1, 0);
+
+ pthread_join(thread_a, NULL);
+ pthread_join(thread_b, NULL);
+ lseek(fd, 0, SEEK_SET);
+ ret = read(fd, buf, sizeof(buf));
+ if(ret == -1)
+ {
+ INFO_PRINTF2(_L("The errno set from read api is %d"),errno);
+ unlink("c:\\readfrom.txt");
+ unlink("c:\\writeto.txt");
+ return KErrGeneral;
+ }
+ if(strncmp(buf,"hello",5)!=0)
+ {
+ INFO_PRINTF1(_L("The test has failed"));
+ unlink("c:\\readfrom.txt");
+ unlink("c:\\writeto.txt");
+ return KErrGeneral;
+ }
+
+ close(fd1);
+ close(fd);
+ unlink("c:\\readfrom.txt");
+ unlink("c:\\writeto.txt");
+ return KErrNone;
+ }
+
+
+TInt CTestSyscalls :: testfsync() // negative test case so on errr conditions returning KErrNone
+ {
+
+ int x = 0,res=KErrNone;
+ x=fsync(0);
+ if(x<0)
+ {
+ INFO_PRINTF1(_L("fsync failed on STDIN"));
+ res=KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("fsync passed on STDIN"));
+ }
+ return res;
+ }
+
+
+
+/*********************************************/
+/*negative test case for Rename()
+To check whether the errno set in the case where we try to rename
+C:\\orig to C:\\\orig\\dest is EINVAL or not*/
+/*********************************************/
+
+TInt CTestSyscalls :: testrename()
+ {
+ int err = 0;
+ int res = mkdir("C:\\Orig\\", 0666) ;
+ if (res < 0)
+ {
+ INFO_PRINTF1(_L("mkdir() for parent directory failed\n"));
+ return res;
+ }
+ /*check for Rename() when old path present and new path absent
+ and new path is the child directory of old path*/
+ res = rename("C:\\Orig\\", "C:\\Orig\\Dest");
+ err = errno;
+ if (err != 22)
+ {
+ INFO_PRINTF4(_L("%d, %d , %s\n"), res, err, strerror(err));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Rename() set the correct errno when C:\\Orig\\Dest\\ is not present\n"));
+ }
+ /*check for Rename() when old path present and new path present
+ and new path is the child directory of old path*/
+ res = mkdir("C:\\Orig\\Dest\\", 0666) ;
+ if (res < 0)
+ {
+ INFO_PRINTF1(_L("mkdir() for child directory failed\n"));
+ return res;
+ }
+ res = rename("C:\\Orig\\", "C:\\Orig\\Dest");
+ err = errno;
+ if (err != 22)
+ {
+ INFO_PRINTF4(_L("%d, %d , %s\n"), res, err, strerror(err));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Rename() set the correct errno when C:\\Orig\\Dest\\ is present\n"));
+ }
+ res = rmdir("C:\\Orig\\Dest\\");
+ if (res < 0)
+ {
+ INFO_PRINTF1(_L("rmdir() for child directory failed\n"));
+ return res;
+ }
+ res = rmdir("C:\\Orig\\");
+ if (res < 0)
+ {
+ INFO_PRINTF1(_L("rmdir() for parent directory failed\n"));
+ return res;
+ }
+ return res;
+ }
+
+/**************************************************************
+negative test case for Open()
+To check whether the errno set in the case where
+we try to open a file in read only mode with O_TRUNC
+errno = EACCES
+we try to open a existing file with O_CREAT and O_EXCL
+errno = EXIST
+we try to open a existing file with O_CREAT, O_EXCL and O_APPEND
+errno = EXIST
+we try to open a existing file with O_CREAT, O_EXCL and O_TRUNC
+errno = EXIST
+****************************************************************/
+
+TInt CTestSyscalls :: testopenvalidate()
+ {
+ INFO_PRINTF1(_L("open a file in read-only mode\n"));
+ int fd = open("c:\\opentest.txt",O_CREAT, S_IRUSR);
+ if (fd < 0)
+ {
+ INFO_PRINTF1(_L("open() a file in read-only mode failed\n"));
+ return fd;
+ }
+ INFO_PRINTF1(_L("open the existing read-only file with O_TRUNC mode\n"));
+ int fd1 = open("c:\\opentest.txt",O_TRUNC);
+ if (fd1 < 0)
+ {
+ INFO_PRINTF1(_L("open the existing read-only file with O_TRUNC mode failed\n"));
+ if (errno != EACCES)
+ {
+ INFO_PRINTF1(_L("open() doesn't set errno correctly for the existing read-only file opened with O_TRUNC mode\n"));
+ return fd1;
+ }
+ INFO_PRINTF2(_L("open() set errno correctly for the existing read-only file opened with O_TRUNC mode to %d\n"), errno);
+ }
+ int ret = close(fd);
+ if (ret < 0)
+ {
+ INFO_PRINTF1(_L("close() for the file fd failed\n"));
+ return ret;
+ }
+ ret = unlink("c:\\opentest.txt");
+ if (ret < 0)
+ {
+ INFO_PRINTF1(_L("unlink() for the file failed\n"));
+ return ret;
+ }
+ INFO_PRINTF1(_L("open a file in read-write mode\n"));
+ int fd2 = open("c:\\opentest.txt",O_CREAT, 0600);
+ if (fd2 < 0)
+ {
+ INFO_PRINTF1(_L("open() for the file in read-write mode failed\n"));
+ return fd2;
+ }
+ INFO_PRINTF1(_L("open the existing file with O_CREAT and O_EXCL mode\n"));
+ int fd3 = open("c:\\opentest.txt",O_CREAT|O_EXCL);
+ if (fd3 < 0)
+ {
+ INFO_PRINTF1(_L("open the existing file with O_CREAT|O_EXCL mode failed\n"));
+ if (errno != EEXIST)
+ {
+ INFO_PRINTF1(_L("open() doesn't set errno correctly for the existing file opened with O_CREAT|O_EXCL mode\n"));
+ return fd3;
+ }
+ INFO_PRINTF2(_L("open() set errno correctly for the existing file opened with O_CREAT|O_EXCL mode to %d\n"), errno);
+ }
+ INFO_PRINTF1(_L("open the existing file with O_CREAT,O_EXCL and O_APPEND mode\n"));
+ int fd4 = open("c:\\opentest.txt",O_CREAT|O_EXCL|O_APPEND);
+ if (fd4 < 0)
+ {
+ INFO_PRINTF1(_L("open the existing file with O_CREAT|O_EXCL|O_APPEND mode failed\n"));
+ if (errno != EEXIST)
+ {
+ INFO_PRINTF1(_L("open() doesn't set errno correctly for the existing file opened with O_CREAT|O_EXCL|O_APPEND mode\n"));
+ return fd4;
+ }
+ INFO_PRINTF2(_L("open() set errno correctly for the existing file opened with O_CREAT|O_EXCL mode to %d\n"), errno);
+ }
+ INFO_PRINTF1(_L("open the existing file with O_CREAT,O_EXCL and O_TRUNC mode\n"));
+ int fd5 = open("c:\\opentest.txt",O_CREAT|O_EXCL|O_TRUNC);
+ if (fd5 < 0)
+ {
+ INFO_PRINTF1(_L("open the existing file with O_CREAT|O_EXCL|O_TRUNC mode failed\n"));
+ if (errno != EEXIST)
+ {
+ INFO_PRINTF1(_L("open() doesn't set errno correctly for the existing file opened with O_CREAT|O_EXCL|O_TRUNC mode\n"));
+ return fd5;
+ }
+ INFO_PRINTF2(_L("open() set errno correctly for the existing file opened with O_CREAT|O_EXCL|O_TRUNC mode to %d\n"), errno);
+ }
+ ret = close(fd2);
+ if (ret < 0)
+ {
+ INFO_PRINTF1(_L("close() for the file fd failed\n"));
+ return ret;
+ }
+ ret = unlink("c:\\opentest.txt");
+ if (ret < 0)
+ {
+ INFO_PRINTF1(_L("unlink() for the file failed\n"));
+ return ret;
+ }
+ return 0;
+ }
+TInt CTestSyscalls :: Fstat1()
+ {
+ int fd ,ret;
+ char* file = "C:\\Test\\Fstatt57.txt";
+ if((fd = open(file , O_CREAT | O_RDWR | O_TRUNC , 0666)) < 0)
+ {
+ _LIT(Kerr , "Failed to open specified file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ ret = fstat(fd,NULL);
+ if(ret == -1)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ return KErrGeneral;
+ }
+ }
+
+TInt CTestSyscalls :: Utimes1()
+ {
+
+ TBuf8<50>string ;
+ TPtrC String ;
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kutimes, "In Utimes" );
+ INFO_PRINTF1(Kutimes);
+
+ struct timeval tim[2] ;
+
+ tim[0].tv_sec = 0 ; tim[0].tv_usec = 0;
+ tim[1].tv_sec = 0 ; tim[1].tv_usec = 0;
+
+ if(utimes(NULL,tim) < 0 )
+ {
+
+ _LIT(Kstmt, "Utime Successful") ;
+ INFO_PRINTF1(Kstmt) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+ }
+TInt CTestSyscalls :: Mkdir_test1()
+ {
+
+ TInt ret,ret1;
+
+ ret1 = mkdir(NULL, S_IWUSR) ;
+
+ if(ret1 == -1 )
+ {
+ _LIT(Kstmt , "mkdir success") ;
+ INFO_PRINTF1(Kstmt);
+ ret= KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Expected and the return values are different ") ;
+ ERR_PRINTF1(Kerr) ;
+ ret = KErrGeneral;
+ }
+ return ret;
+ }
+
+TInt CTestSyscalls :: Chmod_test()
+ {
+ TInt ret1;
+ ret1 = chmod(NULL, S_IWUSR) ;
+
+ if(ret1 == -1)
+ {
+ _LIT(Kstmt, "chmod Success") ;
+ INFO_PRINTF1(Kstmt) ;
+ return KErrNone ;
+ }
+
+ else
+ {
+ _LIT(Kerr , "Failed to change the modes of the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+TInt CTestSyscalls :: Chdir1()
+ {
+ TInt ret ;
+
+ ret = chdir(NULL) ;
+
+ if(ret == -1)
+ {
+ _LIT(Kerr , "Chdir Success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone;
+ }
+ else
+ {
+ _LIT(Kerr, "Expected and return value are different") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+
+TInt CTestSyscalls :: Rmdir2()
+ {
+
+ if(rmdir(NULL) < 0)
+ {
+ _LIT(Kerr , "rmdir success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+ }
+
+TInt CTestSyscalls :: Rename_test()
+ {
+ int ret;
+ ret = rename(NULL,"C:\\Test\\Fstatt57.txt") ;
+
+ if(ret<1)
+ {
+ _LIT(Kerr , "rename success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+ }
+TInt CTestSyscalls :: Rename3()
+ {
+ int ret;
+ ret = rename("C:\\Test\\Fstatt57.txt",NULL) ;
+
+ if(ret<1)
+ {
+ _LIT(Kerr , "rename success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+
+ }
+
+TInt CTestSyscalls :: Creat1( )
+ {
+ int fd ;
+
+ if((fd = creat(NULL, 0666)) < 0)
+ {
+ _LIT(Kstmt , "creat success") ;
+ INFO_PRINTF1(Kstmt) ;
+ return KErrNone ;
+ }
+ close(fd) ;
+ return KErrGeneral ;
+ }
+
+TInt CTestSyscalls :: ReadV1()
+ {
+ char Buf1[20] ; //= "Hello World";
+ char Buf2[20] ; //= "By ritche" ;
+ struct iovec Iovec[2] ;
+ TInt ret=KErrNone;
+ Iovec[0].iov_base = Buf1 ;
+ Iovec[0].iov_len = sizeof("Hello World") ;
+ Iovec[1].iov_base = Buf2 ;
+ Iovec[1].iov_len = sizeof("By ritche") ;
+
+ char *file = "c:\\logs\\temp.txt";
+ TInt fd = open(file , O_CREAT | O_RDWR , 0666) ;
+
+ if(fd < 0)
+ {
+ _LIT(Kerr , "failed to open the given file ") ;
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+
+
+ if(readv(fd , Iovec , -1) < 0 && errno == EINVAL )
+ {
+ _LIT(Kstmt , "readv success") ;
+ INFO_PRINTF1(Kstmt) ;
+ ret = KErrNone ;
+ }
+
+ else
+ {
+ _LIT(Kerr, "readv failure") ;
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+ return ret;
+
+ }
+
+ TInt CTestSyscalls :: Utimes2()
+ {
+
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+
+ _LIT( KTsyscalls, "Tsyscalls" );
+ INFO_PRINTF1(KTsyscalls) ;
+ _LIT( Kutimes, "In Utimes" );
+ INFO_PRINTF1(Kutimes);
+
+ struct timeval tim[2] ;
+
+ tim[0].tv_sec = 0 ; tim[0].tv_usec = 0;
+ tim[1].tv_sec = 0 ; tim[1].tv_usec = 0;
+
+ if(utimes(mbcbuf,tim) < 0 )
+ {
+
+ _LIT(Kstmt, "Utime Successful") ;
+ INFO_PRINTF1(Kstmt) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+ }
+
+ TInt CTestSyscalls :: Stat_test()
+ {
+
+ char mbcbuf[64];
+ int result,ret=KErrNone;
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+
+ struct stat statbuf ;
+ result = stat(mbcbuf , &statbuf) ;
+
+ if(result<0)
+ {
+ _LIT(Kstmt, "stat Successful") ;
+ INFO_PRINTF1(Kstmt) ;
+ }
+ else
+ {
+ _LIT(Kstmt, "stat failure") ;
+ INFO_PRINTF1(Kstmt) ;
+ ret = KErrGeneral ;
+ }
+ return ret;
+ }
+
+ TInt CTestSyscalls :: Mkdir_test2()
+ {
+
+ TInt ret,ret1;
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ ret1 = mkdir(mbcbuf, S_IWUSR) ;
+
+ if(ret1 == -1 )
+ {
+ _LIT(Kstmt , "mkdir success") ;
+ INFO_PRINTF1(Kstmt);
+ ret= KErrNone ;
+ }
+ else
+ {
+ _LIT(Kerr , "Expected and the return values are different ") ;
+ ERR_PRINTF1(Kerr) ;
+ ret = KErrGeneral;
+ }
+ return ret;
+ }
+
+ TInt CTestSyscalls :: Chmod2()
+ {
+ TInt ret1;
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ ret1 = chmod(mbcbuf, S_IWUSR) ;
+
+ if(ret1 == -1)
+ {
+ _LIT(Kstmt, "chmod Success") ;
+ INFO_PRINTF1(Kstmt) ;
+ return KErrNone ;
+ }
+
+ else
+ {
+ _LIT(Kerr , "Failed to change the modes of the file ") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrGeneral ;
+ }
+ }
+ TInt CTestSyscalls :: Chdir2()
+ {
+ TInt ret ;
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ ret = chdir(mbcbuf) ;
+
+ if(ret == -1)
+ {
+ _LIT(Kerr , "Chdir Success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone;
+ }
+ else
+ {
+ _LIT(Kerr, "Expected and return value are different") ;
+ INFO_PRINTF1(Kerr);
+ return KErrGeneral ;
+ }
+ }
+
+ TInt CTestSyscalls :: Rename4()
+ {
+ int ret;
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ ret = rename(mbcbuf,"C:\\Test\\rename1.txt") ;
+
+ if(ret<0)
+ {
+ _LIT(Kerr , "rename success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+
+ }
+ TInt CTestSyscalls :: Rename5()
+ {
+ int ret;
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+ ret = rename("C:\\Test\\rename1.txt",mbcbuf) ;
+
+ if(ret<0)
+ {
+ _LIT(Kerr , "rename success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+
+ }
+ TInt CTestSyscalls :: Rmdir3()
+ {
+ char mbcbuf[64];
+ mbcbuf[0] = (unsigned char)0x3A;// colon :
+
+ if(rmdir(mbcbuf) < 0)
+ {
+ _LIT(Kerr , "rmdir success") ;
+ INFO_PRINTF1(Kerr) ;
+ return KErrNone ;
+ }
+ return KErrGeneral ;
+ }
+
+ TInt CTestSyscalls :: read5()
+ {
+
+ int fd;
+ int ret=KErrNone;
+ char Buf[20] ;
+ if((fd = open("C:\\Test\\rename1.txt" , O_CREAT | O_WRONLY , 0666)) < 0)
+ {
+ _LIT(Kopen , "Failed to open file " ) ;
+ INFO_PRINTF1(Kopen) ;
+ return KErrGeneral ;
+ }
+
+ if(read(fd , Buf , 0) == 0)
+ {
+ if(errno != EBADF)
+ {
+ _LIT(Kstmt , "read success \n") ;
+ INFO_PRINTF1(Kstmt) ;
+ ret = KErrNone ;
+ }
+ }
+
+ else
+ {
+ _LIT(Kerr , "Read failed") ;
+ INFO_PRINTF1(Kerr) ;
+ ret = KErrGeneral ;
+ }
+
+ return ret ;
+
+ }
+
+
+//---------------------------------------------------------------------------
+//Stat Test cases
+//---------------------------------------------------------------------------
+
+
+TInt CTestSyscalls :: Stat3()
+ {
+
+ struct stat buf;
+ if(stat("Y:\\" , &buf) < 0 ) //return -1,if memory card not mounted
+
+ printf("Failed to stat Y:\\n");
+
+ printf("Stat system call succeeded \n");
+ getchar();
+ return 0;
+ }
+
+
+