lcov-1.7 into third_party for code coverage on POSIX systems....

third_party/lcov/descriptions.tests

+personality01  
+        Check that we can set the personality for a process.
+personality02  
+        Check that we get EINVAL for a bad personality.
+exit01  
+        Check that exit returns the correct values to the waiting parent
+exit02  
+        Check that exit flushes output file buffers and closes files upon
+        exiting
+wait02
+        Basic test for wait(2) system call. 
+wait401  
+        check that a call to wait4() correctly waits for a child
+        process to exit
+wait402  
+        check for ECHILD errno when using an illegal pid value
+
+waitpid01  
+        Check that when a child kills itself by generating an alarm
+        exception, the waiting parent is correctly notified.
+waitpid02  
+        Check that when a child kills itself by generating an integer zero
+        divide exception, the waiting parent is correctly notified.
+waitpid03  
+        Check that parent waits until specific child has returned.
+waitpid04  
+        test to check the error conditions in waitpid sys call
+waitpid05  
+        Check that when a child kills itself with a kill statement after
+        determining its process id by using getpid, the parent receives a
+        correct report of the cause of its death. This also indirectly
+        checks that getpid returns the correct process id.
+waitpid06  
+        Tests to see if pid's returned from fork and waitpid are same.
+waitpid07  
+        Tests to see if pid's returned from fork and waitpid are same.
+waitpid08  
+        Tests to see if pid's returned from fork and waitpid are same
+waitpid09  
+        Check ability of parent to wait until child returns, and that the
+        child's process id is returned through the waitpid. Check that
+        waitpid returns immediately if no child is present.
+waitpid10  
+        Tests to see if pid's returned from fork and waitpid are same
+waitpid11  
+        Tests to see if pid's returned from fork and waitpid are same
+waitpid12  
+        Tests to see if pid's returned from fork and waitpid are same
+waitpid13  
+        Tests to see if pid's returned from fork and waitpid are same
+fcntl01  
+        Test F_DUPFD, F_SETFL cmds of fcntl
+fcntl02
+        Basic test for fcntl(2) using F_DUPFD argument.
+fcntl03
+        Basic test for fcntl(2) using F_GETFD argument.
+fcntl04
+        Basic test for fcntl(2) using F_GETFL argument. 
+fcntl05
+        Basic test for fcntl(2) using F_GETLK argument. 
+fcntl06  
+        Error checking conditions for remote locking of regions of a file.
+fcntl07
+        Close-On-Exec functional test. 
+fcntl07B
+        Close-On-Exec of named pipe functional test. 
+fcntl08
+        Basic test for fcntl(2) using F_SETFL argument. 
+fcntl09
+        Basic test for fcntl(2) using F_SETLK argument. 
+fcntl10
+        Basic test for fcntl(2) using F_SETLKW argument. 
+fcntl11  
+        Testcase to check locking of regions of a file
+
+fcntl12  
+
+        Testcase to test that fcntl() sets EMFILE for F_DUPFD command.
+
+fcntl13  
+
+        Testcase to test that fcntl() sets errno correctly.
+
+fcntl14  
+
+        File locking test cases for fcntl. In Linux, S_ENFMT is not implemented
+        in the kernel. However all standard Unix kernels define S_ENFMT as
+        S_ISGID. So this test defines S_ENFMT as S_ISGID.
+
+fcntl15  
+
+        Check that file locks are removed when file closed
+
+fcntl16  
+
+        Additional file locking test cases for checking proper notification
+        of processes on lock change
+
+fcntl17  
+
+        Check deadlock detection for file locking
+
+fcntl18  
+
+        Test to check the error conditions in fcntl system call
+
+fcntl19  
+
+        Testcase to check locking of regions of a file
+
+fcntl20  
+
+        Check locking of regions of a file
+
+fcntl21  
+
+        Check locking of regions of a file
+
+dup01           
+
+        Basic test for dup(2).
+
+dup02                   
+
+        Negative test for dup(2) with bad fd.
+
+dup03
+
+        Negative test for dup(2) (too many fds).
+
+dup04
+
+        Basic test for dup(2) of a system pipe descriptor.
+
+dup05
+
+        Basic test for dup(2) of a named pipe descriptor. 
+
+dup201  
+
+        Negative tests for dup2() with bad fd (EBADF), and for "too many
+        open files" (EMFILE)
+
+dup202  
+
+        Is the access mode the same for both file descriptors?
+        0: read only ?  "0444"
+        1: write only ? "0222"
+        2: read/write ? "0666"
+
+dup203  
+
+        Testcase to check the basic functionality of dup2().
+
+dup204  
+
+        Testcase to check the basic functionality of dup2(2).
+
+
+msync01  
+
+        Verify that, msync() succeeds, when the region to synchronize, is part
+        of, or all of a mapped region.
+
+msync02  
+
+        Verify that msync() succeeds when the region to synchronize is mapped
+        shared and the flags argument is MS_INVALIDATE.
+
+msync03  
+
+        Verify that, msync() fails, when the region to synchronize, is outside
+        the address space of the process.
+
+msync04  
+
+        Verify that, msync() fails, when the region to synchronize, is mapped
+        but the flags argument is invalid.
+
+msync05  
+
+        Verify that, msync() fails, when the region to synchronize, was not
+        mapped.
+
+
+sendfile02  
+
+        Testcase to test the basic functionality of the sendfile(2) system call.
+
+sendfile03  
+
+        Testcase to test that sendfile(2) system call returns appropriate
+        errnos on error.
+
+fork01
+        Basic test for fork(2). 
+fork02  
+        Test correct operation of fork:
+        pid == 0 in child;
+        pid > 0 in parent from wait;
+fork03  
+        Check that child can use a large text space and do a large
+        number of operations.   
+fork04
+        Child inheritance of Environment Variables after fork(). 
+fork05
+        Make sure LDT is propagated correctly 
+fork06  
+        Test that a process can fork children a large number of
+        times in succession
+fork07  
+        Check that all children inherit parent's file descriptor
+fork08  
+        Check if the parent's file descriptors are affected by 
+        actions in the child; they should not be.
+fork09  
+        Check that child has access to a full set of files.
+fork10  
+        Check inheritance of file descriptor by children, they
+        should all be referring to the same file.
+fork11  
+        Test that parent gets a pid from each child when doing wait
+vfork01  
+        Fork a process using vfork() and verify that, the attribute values like
+        euid, ruid, suid, egid, rgid, sgid, umask, inode and device number of
+        root and current working directories are same as that of the parent 
+        process.
+vfork02  
+        Fork a process using vfork() and verify that, the pending signals in
+        the parent are not pending in the child process.
+ioctl01  
+
+        Testcase to check the errnos set by the ioctl(2) system call.
+
+ioctl02  
+
+        Testcase to test the TCGETA, and TCSETA ioctl implementations for
+        the tty driver
+
+sockioctl01  
+
+        Verify that ioctl() on sockets returns the proper errno for various
+        failure cases
+
+getitimer01
+        check that a correct call to getitimer() succeeds
+
+
+getitimer02
+        check that a getitimer() call fails as expected
+        with an incorrect second argument.
+
+getitimer03
+        check that a getitimer() call fails as expected
+        with an incorrect first argument.
+
+setitimer01
+        check that a reasonable setitimer() call succeeds.
+
+
+setitimer02
+        check that a setitimer() call fails as expected
+        with incorrect values.
+
+setitimer03
+        check that a setitimer() call fails as expected
+        with incorrect values.
+
+float_trigo
+        increase CPUs workload - verify that results of some math functions are stable
+        trigonometric (acos, asin, atan, atan2, cos, sin, tan),
+        hyperbolic (cosh, sinh, tanh),
+
+float_exp_log
+        increase CPUs workload - verify that results of some math functions are stable
+        exponential and logarithmic functions (exp, log, log10),
+        Functions that manipulate floating-point numbers (modf, ldexp, frexp),
+        Euclidean distance function (hypot),
+
+float_bessel
+        increase CPUs workload - verify that results of some math functions are stable
+        Bessel (j0, j1, y0, y1),
+        Computes the natural logarithm of the gamma function (lgamma),
+
+fload_power
+        increase CPUs workload - verify that results of some math functions are stable
+        Computes sqrt, power, fmod
+
+float_iperb
+        increase CPUs workload - verify that results of some math functions are stable
+pth_str01
+
+        Creates a tree of threads
+
+pth_str02
+
+        Creates n threads
+
+pth_str03
+
+        Creates a tree of threads does calculations, and
+        returns result to parent
+
+
+asyncio02
+
+        Write/close flushes data to the file.
+
+
+fpathconf
+
+        Basic test for fpathconf(2)
+
+gethostid01
+
+        Basic test for gethostid(2) 
+
+
+pathconf01
+
+        Basic test for pathconf(2) 
+
+setpgrp01
+
+        Basic test for the setpgrp(2) system call.  
+
+setpgrp02  
+
+        Testcase to check the basic functionality of the setpgrp(2) syscall.
+
+
+ulimit01
+
+        Basic test for the ulimit(2) system call. 
+
+mmstress
+
+        Performs General Stress with Race conditions
+
+mmap1
+
+        Test the LINUX memory manager. The program is aimed at
+        stressing the memory manager by simultaneous map/unmap/read
+        by light weight processes, the test is scheduled to run for
+        a minimum of 24 hours.
+
+mmap2
+
+        Test the LINUX memory manager. The program is aimed at
+        stressing the memory manager by repeated map/write/unmap of a
+        of a large gb size file.
+
+mmap3
+
+        Test the LINUX memory manager. The program is aimed at
+        stressing the memory manager by repeated map/write/unmap
+        of file/memory of random size (maximum 1GB) this is done by
+        multiple processes.
+
+mmap001
+
+        Tests mmapping a big file and writing it once 
+
+mmap01  
+
+        Verify that, mmap() succeeds when used to map a file where size of the
+        file is not a multiple of the page size, the memory area beyond the end
+        of the file to the end of the page is accessible. Also, verify that
+        this area is all zeroed and the modifications done to this area are
+        not written to the file.
+
+mmap02  
+
+        Call mmap() with prot parameter set to PROT_READ and with the file
+        descriptor being open for read, to  map a file creating mapped memory
+        with read access. The minimum file permissions should be 0444.
+
+mmap03  
+
+        Call mmap() to map a file creating a mapped region with execute access
+        under the following conditions -
+        - The prot parameter is set to PROT_EXE
+        - The file descriptor is open for read
+        - The file being mapped has execute permission bit set.
+        - The minimum file permissions should be 0555.
+
+        The call should succeed to map the file creating mapped memory with the
+        required attributes.
+
+mmap04  
+
+        Call mmap() to map a file creating a mapped region with read/exec access
+        under the following conditions -
+        - The prot parameter is set to PROT_READ|PROT_EXEC
+        - The file descriptor is open for read
+        - The file being mapped has read and execute permission bit set.
+        - The minimum file permissions should be 0555.
+
+        The call should succeed to map the file creating mapped memory with the
+        required attributes.
+
+
+mmap05  
+
+        Call mmap() to map a file creating mapped memory with no access under
+        the following conditions -
+        - The prot parameter is set to PROT_NONE
+        - The file descriptor is open for read(any mode other than write)
+        - The minimum file permissions should be 0444.
+
+        The call should succeed to map the file creating mapped memory with the
+        required attributes.
+
+mmap06  
+
+        Call mmap() to map a file creating a mapped region with read access
+        under the following conditions -
+        - The prot parameter is set to PROT_READ
+        - The file descriptor is open for writing.
+
+        The call should fail to map the file.
+
+
+mmap07  
+
+        Call mmap() to map a file creating a mapped region with read access
+        under the following conditions -
+        - The prot parameter is set to PROT_WRITE
+        - The file descriptor is open for writing.
+        - The flags parameter has MAP_PRIVATE set.
+
+        The call should fail to map the file.
+
+mmap08  
+
+        Verify that mmap() fails to map a file creating a mapped region 
+        when the file specified by file descriptor is not valid.
+
+
+mremap01  
+
+        Verify that, mremap() succeeds when used to expand the existing
+        virtual memory mapped region to the requested size where the
+        virtual memory area was previously mapped to a file using mmap().
+
+mremap02  
+
+        Verify that, 
+        mremap() fails when used to expand the existing virtual memory mapped 
+        region to the requested size, if the virtual memory area previously 
+        mapped was not page aligned or invalid argument specified.
+
+mremap03  
+
+        Verify that, 
+        mremap() fails when used to expand the existing virtual memory mapped 
+        region to the requested size, if there already exists mappings that
+        cover the whole address space requested or the old address specified was
+        not mapped.
+
+mremap04  
+
+        Verify that, 
+        mremap() fails when used to expand the existing virtual memory mapped 
+        region to the requested size, if the memory area cannot be expanded at
+        the current virtual address and MREMAP_MAYMOVE flag not set.
+
+munmap01  
+
+        Verify that, munmap call will succeed to unmap a mapped file or
+        anonymous shared memory region from the calling process's address space
+        and after successful completion of munmap, the unmapped region is no
+        longer accessible.
+
+munmap02  
+
+        Verify that, munmap call will succeed to unmap a mapped file or
+        anonymous shared memory region from the calling process's address space
+        if the region specified by the address and the length is part or all of
+        the mapped region.
+
+munmap03  
+
+        Verify that, munmap call will fail to unmap a mapped file or anonymous
+        shared memory region from the calling process's address space if the
+        address and the length of the region to be unmapped points outside the
+        calling process's address space
+
+brk01
+        Test the basic functionality of brk.
+
+sbrk01
+        Basic test for the sbrk(2) system call.
+
+
+mprotect01  
+
+        Testcase to check the error conditions for mprotect(2)
+
+mprotect02  
+
+        Testcase to check the mprotect(2) system call.
+
+mprotect03  
+
+        Testcase to check the mprotect(2) system call.
+
+msgctl01 
+        create a message queue, then issue the IPC_STAT command
+        and RMID commands to test the functionality
+
+
+msgctl02 
+        create a message queue, then issue the IPC_SET command
+        to lower the msg_qbytes value.
+
+
+msgctl03
+        create a message queue, then issue the IPC_RMID command
+
+
+
+msgctl04 
+        test for EACCES, EFAULT and EINVAL errors using
+        a variety of incorrect calls.
+
+
+msgctl05 
+        test for EPERM error
+
+
+
+msgget01 
+        create a message queue, write a message to it and
+        read it back.
+
+
+msgget02 
+        test for EEXIST and ENOENT errors
+
+
+msgget03 
+        test for an ENOSPC error by using up all available
+        message queues.
+
+msgget04 
+        test for an EACCES error by creating a message queue
+        with no read or write permission and then attempting
+        to access it with various permissions.
+
+msgrcv01 
+        test that msgrcv() receives the expected message
+
+msgrcv02
+        test for EACCES and EFAULT errors
+
+msgrcv03
+        test for EINVAL error
+
+msgrcv04
+        test for E2BIG and ENOMSG errors
+
+msgrcv05
+        test for EINTR error
+
+msgrcv06
+        test for EIDRM error
+
+msgsnd01
+        test that msgsnd() enqueues a message correctly
+
+msgsnd02
+        test for EACCES and EFAULT errors
+
+msgsnd03
+        test for EINVAL error
+
+msgsnd04
+        test for EAGAIN error
+
+msgsnd05
+        test for EINTR error
+
+
+msgsnd06
+        test for EIDRM error
+
+link02
+
+        Basic test for link(2) 
+
+link03
+
+        Multi links tests
+
+link04
+
+        Negative test cases for link(2)
+
+link05
+
+        Multi links (EMLINK) negative test 
+
+readlink01  
+
+        Verify that, readlink will succeed to read the contents of the symbolic
+        link created the process.
+
+readlink02
+
+        Basic test for the readlink(2) system call 
+
+readlink03  
+
+        Verify that,
+        1) readlink(2) returns -1 and sets errno to EACCES if search/write
+        permission is denied in the directory where the symbolic link
+        resides.
+        2) readlink(2) returns -1 and sets errno to EINVAL if the buffer size
+        is not positive.
+        3) readlink(2) returns -1 and sets errno to EINVAL if the specified
+        file is not a symbolic link file.
+        4) readlink(2) returns -1 and sets errno to ENAMETOOLONG if the 
+        pathname component of symbolic link is too long (ie, > PATH_MAX).
+        5) readlink(2) returns -1 and sets errno to ENOENT if the component of
+        symbolic link points to an empty string.
+
+readlink04  
+
+        Verify that, readlink call will succeed to read the contents of the
+        symbolic link if invoked by non-root user who is not the owner of the
+        symbolic link.
+
+
+symlink01
+
+        Test of various file function calls, such as rename or open, on a symbolic 
+        link file. 
+
+symlink02
+
+        Basic test for the symlink(2) system call. 
+
+symlink03  
+
+        Verify that,
+        1) symlink(2) returns -1 and sets errno to EACCES if search/write
+        permission is denied in the directory where the symbolic link is
+        being created.
+        2) symlink(2) returns -1 and sets errno to EEXIST if the specified 
+        symbolic link already exists.
+        3) symlink(2) returns -1 and sets errno to EFAULT if the specified
+        file or symbolic link points to invalid address.
+        4) symlink(2) returns -1 and sets errno to ENAMETOOLONG if the 
+        pathname component of symbolic link is too long (ie, > PATH_MAX).
+        5) symlink(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname of symbolic link is not a directory.
+        6) symlink(2) returns -1 and sets errno to ENOENT if the component of
+        symbolic link points to an empty string.
+
+symlink04  
+
+        Verify that, symlink will succeed to create a symbolic link of an existing
+        object name path.
+
+
+symlink05  
+
+        Verify that, symlink will succeed to create a symbolic link of an
+        non-existing object name path.
+
+
+unlink05
+
+        Basic test for the unlink(2) system call. 
+
+unlink06
+
+        Test for the unlink(2) system call of a FIFO. 
+
+unlink07
+
+        Tests for error handling for the unlink(2) system call. 
+
+unlink08
+
+        More tests for error handling for the unlink(2) system call.
+
+
+linktest
+
+        Regression test for max links per file
+
+rename01  
+
+        This test will verify the rename(2) syscall basic functionality.
+        Verify rename() works when the "new" file or directory does not exist.
+
+rename02
+
+        Basic test for the rename(2) system call
+
+rename03  
+
+        This test will verify that rename(2) functions correctly
+        when the "new" file or directory exists
+
+rename04  
+
+        This test will verify that rename(2) failed when newpath is 
+        a non-empty directory and return EEXIST or ENOTEMPTY
+
+rename05  
+
+        This test will verify that rename(2) fails with EISDIR
+
+rename06  
+
+        This test will verify that rename(2) failed in EINVAL
+
+rename07  
+
+        This test will verify that rename(2) failed in ENOTDIR
+
+rename08  
+
+        This test will verify that rename(2) syscall failed in EFAULT
+
+rename09  
+
+        check rename() fails with EACCES
+
+rename10  
+
+        This test will verify that rename(2) syscall fails with ENAMETOOLONG
+        and ENOENT
+
+rename11  
+
+        This test will verify that rename(2) failed in EBUSY
+
+rename12  
+
+        check rename() fails with EPERM
+
+rename13  
+
+        Verify rename() return successfully and performs no other action
+        when "old" file and "new" file link to the same file.
+
+rmdir01  
+
+        This test will verify that rmdir(2) syscall basic functionality.
+        verify rmdir(2) returns a value of 0 and the directory being
+        removed 
+
+rmdir02  
+
+        This test will verify that rmdir(2) fail in 
+        1. ENOTEMPTY
+        2. EBUSY
+        3. ENAMETOOLONG
+        4. ENOENT
+        5. ENOTDIR
+        6. EFAULT
+        7. EFAULT
+
+rmdir03  
+
+        check rmdir() fails with EPERM or EACCES
+
+rmdir04
+
+        Basic test for the rmdir(2) system call 
+
+rmdir05
+
+        Verify that rmdir(2) returns a value of -1 and sets errno to indicate the error.
+
+
+
+mkdir01
+
+        Basic errno test for mkdir(2) 
+
+mkdir02  
+
+        This test will verify that new directory created
+        by mkdir(2) inherits the group ID from the parent
+        directory and S_ISGID bit, if the S_ISGID bit is set
+        in the parent directory.
+
+mkdir03  
+
+        Check mkdir() with various error conditions that should produce
+        EFAULT, ENAMETOOLONG, EEXIST, ENOENT and ENOTDIR
+
+mkdir04  
+
+        Attempt to create a directory in a directory having no permissions. 
+
+mkdir05  
+
+        This test will verify the mkdir(2) syscall basic functionality
+
+mkdir08
+
+        Basic test for mkdir(2)
+
+
+mknod01
+
+        Basic test for mknod(2) 
+
+mknod02  
+
+        Verify that mknod(2) succeeds when used to create a filesystem 
+        node with set group-ID bit set on a directory without set group-ID bit set.
+        The node created should have set group-ID bit set and its gid should be 
+        equal to that of its parent directory.
+
+mknod03  
+
+        Verify that mknod(2) succeeds when used to create a filesystem 
+        node with set group-ID bit set on a directory with set group-ID bit set.
+        The node created should have set group-ID bit set and its gid should be 
+        equal to the effective gid of the process.
+
+mknod04  
+
+        Verify that mknod(2) succeeds when used to create a filesystem 
+        node on a directory with set group-ID bit set.
+        The node created should not have group-ID bit set and its gid should be 
+        equal to the effective gid of the process.
+
+mknod05  
+
+        Verify that mknod(2) succeeds when used by root to create a filesystem 
+        node with set group-ID bit set on a directory with set group-ID bit set.
+        The node created should have set group-ID bit set and its gid should be 
+        equal to that of its parent directory.
+
+
+mknod06  
+
+        Verify that,
+        1) mknod(2) returns -1 and sets errno to EEXIST if specified path
+        already exists.
+        2) mknod(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        3) mknod(2) returns -1 and sets errno to ENOENT if the directory 
+        component in pathname does not exist.
+        4) mknod(2) returns -1 and sets errno to ENAMETOOLONG if the pathname
+        component was too long.
+        5) mknod(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname is not a directory.
+
+mknod07  
+
+        Verify that,
+        1) mknod(2) returns -1 and sets errno to EPERM if the process id of
+        the caller is not super-user.
+        2) mknod(2) returns -1 and sets errno to EACCES if parent directory
+        does not allow  write  permission  to  the process.
+
+mknod08  
+
+        Verify that mknod(2) succeeds when used to create a filesystem 
+        node on a directory without set group-ID bit set. The node created
+        should not have set group-ID bit set and its gid should be equal to that
+        of its parent directory.
+
+
+
+
+access01
+
+        Basic test for access(2) using F_OK, R_OK, W_OK, and X_OK  arguments.
+
+access02  
+
+        Verify that access() succeeds to check the read/write/execute permissions
+        on a file if the mode argument passed was R_OK/W_OK/X_OK.
+
+        Also verify that, access() succeeds to test the accessibility of the file
+        referred to by symbolic link if the pathname points to a symbolic link.
+
+access03
+
+        EFAULT error testing for access(2).
+
+access04  
+
+        Verify that,
+        1. access() fails with -1 return value and sets errno to EACCES
+        if the permission bits of the file mode do not permit the
+        requested (Read/Write/Execute) access.
+        2. access() fails with -1 return value and sets errno to EINVAL
+        if the specified access mode argument is invalid.
+        3. access() fails with -1 return value and sets errno to EFAULT
+        if the pathname points outside allocate address space for the
+        process.
+        4. access() fails with -1 return value and sets errno to ENOENT
+        if the specified file doesn't exist (or pathname is NULL).
+        5. access() fails with -1 return value and sets errno to ENAMETOOLONG
+        if the pathname size is > PATH_MAX characters.
+
+access05  
+
+        Verify that access() succeeds to check the existence of a file if
+        search access is permitted on the pathname of the specified file.
+
+access06
+
+        EFAULT error testing for access(2).
+
+chroot01  
+
+        Testcase to check the whether chroot sets errno to EPERM.
+
+chroot02  
+
+        Test functionality of chroot(2)
+
+chroot03  
+
+        Testcase to test whether chroot(2) sets errno correctly.
+
+pipeio
+
+        This tool can be used to beat on system or named pipes.
+        See the help() function below for user information.
+
+pipe01  
+
+        Testcase to check the basic functionality of the pipe(2) syscall:
+        Check that both ends of the pipe (both file descriptors) are
+        available to a process opening the pipe.
+
+pipe05  
+
+        Check what happens when pipe is passed a bad file descriptor.
+
+pipe06  
+
+        Check what happens when the system runs out of pipes.
+
+pipe08  
+
+        Check that a SIGPIPE signal is generated when a write is
+        attempted on an empty pipe.
+
+pipe09  
+
+        Check that two processes can use the same pipe at the same time.
+
+pipe10  
+
+        Check that parent can open a pipe and have a child read from it
+
+pipe11  
+
+        Check if many children can read what is written to a pipe by the
+        parent.
+
+
+sem01
+
+        Creates a semaphore and two processes.  The processes
+        each go through a loop where they semdown, delay for a
+        random amount of time, and semup, so they will almost
+        always be fighting for control of the semaphore.
+
+sem02
+        The application creates several threads using pthread_create().
+        One thread performs a semop() with the SEM_UNDO flag set. The
+        change in semaphore value performed by that semop should be
+        "undone" only when the last pthread exits.
+
+
+semctl01  
+
+        test the 10 possible semctl() commands
+
+semctl02  
+
+        test for EACCES error
+
+semctl03  
+
+        test for EINVAL and EFAULT errors
+
+semctl04 
+
+        test for EPERM error
+
+
+semctl05
+
+        test for ERANGE error
+
+semget01
+
+        test that semget() correctly creates a semaphore set
+
+semget02 
+
+        test for EACCES and EEXIST errors
+
+semget03 
+
+        test for ENOENT error
+
+semget05 
+
+        test for ENOSPC error
+
+semget06
+
+        test for EINVAL error
+
+semop01 
+
+        test that semop() basic functionality is correct
+
+semop02
+
+        test for E2BIG, EACCES, EFAULT and EINVAL errors
+
+semop03
+
+        test for EFBIG error
+
+semop04
+
+        test for EAGAIN error
+
+semop05
+
+        test for EINTR and EIDRM errors
+
+
+
+msgctl01 
+        create a message queue, then issue the IPC_STAT command
+        and RMID commands to test the functionality
+
+
+msgctl02 
+        create a message queue, then issue the IPC_SET command
+        to lower the msg_qbytes value.
+
+
+msgctl03
+        create a message queue, then issue the IPC_RMID command
+
+
+
+msgctl04 
+        test for EACCES, EFAULT and EINVAL errors using
+        a variety of incorrect calls.
+
+
+msgctl05 
+        test for EPERM error
+
+
+
+msgget01 
+        create a message queue, write a message to it and
+        read it back.
+
+
+msgget02 
+        test for EEXIST and ENOENT errors
+
+
+msgget03 
+        test for an ENOSPC error by using up all available
+        message queues.
+
+msgget04 
+        test for an EACCES error by creating a message queue
+        with no read or write permission and then attempting
+        to access it with various permissions.
+
+msgrcv01 
+        test that msgrcv() receives the expected message
+
+msgrcv02
+        test for EACCES and EFAULT errors
+
+msgrcv03
+        test for EINVAL error
+
+msgrcv04
+        test for E2BIG and ENOMSG errors
+
+msgrcv05
+        test for EINTR error
+
+msgrcv06
+        test for EIDRM error
+
+msgsnd01
+        test that msgsnd() enqueues a message correctly
+
+msgsnd02
+        test for EACCES and EFAULT errors
+
+msgsnd03
+        test for EINVAL error
+
+msgsnd04
+        test for EAGAIN error
+
+msgsnd05
+        test for EINTR error
+
+
+msgsnd06
+        test for EIDRM error
+
+shmat01
+        test that shmat() works correctly
+
+shmat02
+        check for EINVAL and EACCES errors
+
+
+shmat03
+        test for EACCES error
+
+
+shmctl01
+        test the IPC_STAT, IPC_SET and IPC_RMID commands as
+        they are used with shmctl()
+
+
+shmctl02
+        check for EACCES, EFAULT and EINVAL errors
+
+
+shmctl03
+        check for EACCES, and EPERM errors
+
+
+shmdt01
+        check that shared memory is detached correctly
+
+
+shmdt02
+        check for EINVAL error
+
+
+shmget01
+        test that shmget() correctly creates a shared memory segment
+
+
+shmget02
+        check for ENOENT, EEXIST and EINVAL errors
+
+
+shmget03
+        test for ENOSPC error
+
+
+shmget04
+        test for EACCES error
+
+
+shmget05
+        test for EACCES error
+
+openfile
+
+        Creates files and opens simultaneously
+
+open01  
+
+        Open a file with oflag = O_CREAT set, does it set the sticky bit off?
+
+        Open "/tmp" with O_DIRECTORY, does it set the S_IFDIR bit on?
+
+open02  
+
+        Test if open without O_CREAT returns -1 if a file does not exist.
+
+open03
+
+        Basic test for open(2)  
+
+open04  
+
+        Testcase to check that open(2) sets EMFILE if a process opens files
+        more than its descriptor size
+
+open05  
+
+        Testcase to check open(2) sets errno to EACCES correctly.
+
+open06  
+
+        Testcase to check open(2) sets errno to ENXIO correctly.
+
+open07  
+
+        Test the open(2) system call to ensure that it sets ELOOP correctly.
+
+open08  
+
+        Check for the following errors:
+        1.      EEXIST
+        2.      EISDIR
+        3.      ENOTDIR
+        4.      ENAMETOOLONG
+        5.      EFAULT
+        6.      ETXTBSY
+
+
+openfile
+
+        Creates files and opens simultaneously
+
+
+chdir01  
+
+        Check proper operation of chdir(): tests whether the
+        system call can it change the current, working directory, and find a
+        file there? Will it fail on a non-directory entry ?
+
+chdir02         
+
+        Basic test for chdir(2).
+
+chdir03  
+
+        Testcase for testing that chdir(2) sets EACCES errno
+
+chdir04  
+
+        Testcase to test whether chdir(2) sets errno correctly.
+
+
+chmod01  
+
+        Verify that, chmod(2) succeeds when used to change the mode permissions
+        of a file. 
+
+chmod02
+
+        Basic test for chmod(2).
+
+chmod03  
+
+        Verify that, chmod(2) will succeed to change the mode of a file
+        and set the sticky bit on it if invoked by non-root (uid != 0)
+        process with the following constraints,
+        - the process is the owner of the file.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is equal to the group ID of the file.
+
+chmod04  
+
+        Verify that, chmod(2) will succeed to change the mode of a directory
+        and set the sticky bit on it if invoked by non-root (uid != 0) process
+        with the following constraints,
+        - the process is the owner of the directory.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is equal to the group ID of the directory.
+
+chmod05  
+
+        Verify that, chmod(2) will succeed to change the mode of a directory
+        but fails to set the setgid bit on it if invoked by non-root (uid != 0)
+        process with the following constraints,
+        - the process is the owner of the directory.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is not equal to the group ID of the directory.
+
+chmod06  
+
+        Verify that,
+        1) chmod(2) returns -1 and sets errno to EPERM if the effective user id
+        of process does not match the owner of the file and the process is
+        not super user.
+        2) chmod(2) returns -1 and sets errno to EACCES if search permission is
+        denied on a component of the path prefix.
+        3) chmod(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        4) chmod(2) returns -1 and sets errno to ENAMETOOLONG if the pathname
+        component is too long.
+        5) chmod(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname is not a directory.
+        6) chmod(2) returns -1 and sets errno to ENOENT if the specified file
+        does not exists.
+
+chmod07  
+
+        Verify that, chmod(2) will succeed to change the mode of a file/directory
+        and sets the sticky bit on it if invoked by root (uid = 0) process with
+        the following constraints,
+        - the process is not the owner of the file/directory.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is equal to the group ID of the file/directory.
+
+
+chown01
+
+        Basic test for chown(2).
+
+chown02  
+
+        Verify that, when chown(2) invoked by super-user to change the owner and
+        group of a file specified by path to any numeric owner(uid)/group(gid)
+        values,
+        - clears setuid and setgid bits set on an executable file.
+        - preserves setgid bit set on a non-group-executable file.
+
+chown03  
+
+        Verify that, chown(2) succeeds to change the group of a file specified
+        by path when called by non-root user with the following constraints,
+        - euid of the process is equal to the owner of the file.         
+        - the intended gid is either egid, or one of the supplementary gids
+        of the process.
+        Also, verify that chown() clears the setuid/setgid bits set on the file.
+
+chown04  
+
+        Verify that,
+        1) chown(2) returns -1 and sets errno to EPERM if the effective user id
+        of process does not match the owner of the file and the process is
+        not super user.
+        2) chown(2) returns -1 and sets errno to EACCES if search permission is
+        denied on a component of the path prefix.
+        3) chown(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        4) chown(2) returns -1 and sets errno to ENAMETOOLONG if the pathname
+        component is too long.
+        5) chown(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname is not a directory.
+        6) chown(2) returns -1 and sets errno to ENOENT if the specified file
+        does not exists.
+
+chown05  
+
+        Verify that, chown(2) succeeds to change the owner and group of a file
+        specified by path to any numeric owner(uid)/group(gid) values when invoked 
+        by super-user.
+
+
+close01  
+
+        Test that closing a regular file and a pipe works correctly
+
+close02  
+
+        Check that an invalid file descriptor returns EBADF
+
+close08
+
+        Basic test for close(2).
+
+
+fchdir01  
+
+        create a directory and cd into it.
+
+fchdir02  
+
+        try to cd into a bad directory (bad fd).
+
+
+fchmod01
+
+        Basic test for Fchmod(2).
+
+fchmod02  
+
+        Verify that, fchmod(2) will succeed to change the mode of a file/directory
+        set the sticky bit on it if invoked by root (uid = 0) process with
+        the following constraints,
+        - the process is not the owner of the file/directory.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is equal to the group ID of the file/directory.
+
+fchmod03  
+
+        Verify that, fchmod(2) will succeed to change the mode of a file
+        and set the sticky bit on it if invoked by non-root (uid != 0)
+        process with the following constraints,
+        - the process is the owner of the file.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is equal to the group ID of the file.
+
+fchmod04  
+
+        Verify that, fchmod(2) will succeed to change the mode of a directory
+        and set the sticky bit on it if invoked by non-root (uid != 0) process
+        with the following constraints,
+        - the process is the owner of the directory.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is equal to the group ID of the directory.
+
+fchmod05  
+
+        Verify that, fchmod(2) will succeed to change the mode of a directory
+        but fails to set the setgid bit on it if invoked by non-root (uid != 0)
+        process with the following constraints,
+        - the process is the owner of the directory.
+        - the effective group ID or one of the supplementary group ID's of the
+        process is not equal to the group ID of the directory.
+
+fchmod06  
+
+        Verify that,
+        1) fchmod(2) returns -1 and sets errno to EPERM if the effective user id
+        of process does not match the owner of the file and the process is
+        not super user.
+        2) fchmod(2) returns -1 and sets errno to EBADF if the file descriptor
+        of the specified file is not valid.
+
+fchmod07  
+
+        Verify that, fchmod(2) succeeds when used to change the mode permissions
+        of a file specified by file descriptor. 
+
+
+fchown01
+
+        Basic test for fchown(2).
+
+fchown02  
+
+        Verify that, when fchown(2) invoked by super-user to change the owner and
+        group of a file specified by file descriptor to any numeric 
+        owner(uid)/group(gid) values,
+        - clears setuid and setgid bits set on an executable file.
+        - preserves setgid bit set on a non-group-executable file.
+
+fchown03  
+
+        Verify that, fchown(2) succeeds to change the group of a file specified
+        by path when called by non-root user with the following constraints,
+        - euid of the process is equal to the owner of the file.         
+        - the intended gid is either egid, or one of the supplementary gids
+        of the process.
+        Also, verify that fchown() clears the setuid/setgid bits set on the file.
+
+fchown04  
+
+        Verify that,
+        1) fchown(2) returns -1 and sets errno to EPERM if the effective user id
+        of process does not match the owner of the file and the process is
+        not super user.
+        2) fchown(2) returns -1 and sets errno to EBADF if the file descriptor
+        of the specified file is not valid.
+
+fchown05  
+
+        Verify that, fchown(2) succeeds to change the owner and group of a file
+        specified by file descriptor to any numeric owner(uid)/group(gid) values 
+        when invoked by super-user.
+
+lchown01  
+
+        Verify that, lchown(2) succeeds to change the owner and group of a file
+        specified by path to any numeric owner(uid)/group(gid) values when invoked 
+        by super-user.
+
+
+lchown02  
+
+        Verify that,
+        1) lchown(2) returns -1 and sets errno to EPERM if the effective user id
+        of process does not match the owner of the file and the process is
+        not super user.
+        2) lchown(2) returns -1 and sets errno to EACCES if search permission is
+        denied on a component of the path prefix.
+        3) lchown(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        4) lchown(2) returns -1 and sets errno to ENAMETOOLONG if the pathname
+        component is too long.
+        5) lchown(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname is not a directory.
+        6) lchown(2) returns -1 and sets errno to ENOENT if the specified file
+        does not exists.
+
+
+creat01  
+
+        Testcase to check the basic functionality of the creat(2) system call.
+
+creat03  
+
+        Testcase to check whether the sticky bit cleared.
+
+creat04  
+
+        Testcase to check creat(2) fails with EACCES
+
+creat05  
+
+        Testcase to check that creat(2) system call returns EMFILE.
+
+creat06  
+
+        Testcase to check creat(2) sets the following errnos correctly:
+        1.      EISDIR
+        2.      ENAMETOOLONG
+        3.      ENOENT
+        4.      ENOTDIR
+        5.      EFAULT
+        6.      EACCES
+
+creat07  
+
+        Testcase to check creat(2) sets the following errnos correctly:
+        1.      ETXTBSY
+
+creat09
+
+        Basic test for creat(2) using 0700 argument.
+
+truncate01  
+
+        Verify that, truncate(2) succeeds to truncate a file to a specified
+        length.
+
+
+truncate02  
+
+        Verify that, truncate(2) succeeds to truncate a file to a certain length,
+        but the attempt to read past the truncated length will fail.  
+
+
+truncate03  
+
+        Verify that,
+        1) truncate(2) returns -1 and sets errno to EACCES if search/write
+        permission denied for the process on the component of the path prefix
+                or named file.
+        2) truncate(2) returns -1 and sets errno to ENOTDIR if the component of
+        the path prefix is not a directory.
+        3) truncate(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        4) truncate(2) returns -1 and sets errno to ENAMETOOLONG if the component
+        of a pathname exceeded 255 characters or entire pathname exceeds 1023
+        characters.
+        5) truncate(2) returns -1 and sets errno to ENOENT if the named file
+        does not exist.
+
+ftruncate01  
+
+        Verify that, ftruncate(2) succeeds to truncate a file to a specified
+        length if the file indicated by file descriptor opened for writing.
+
+ftruncate02  
+
+        Verify that, ftruncate(2) succeeds to truncate a file to a certain length,
+        but the attempt to read past the truncated length will fail.  
+
+ftruncate03  
+
+        Verify that,
+        1) ftruncate(2) returns -1 and sets errno to EINVAL if the specified
+        truncate length is less than 0.
+        2) ftruncate(2) returns -1 and sets errno to EBADF if the file descriptor
+        of the specified file is not valid.
+
+vhangup01  
+
+        Check the return value, and errno of vhangup(2)
+        when a non-root user calls vhangup().
+
+vhangup02  
+
+        To test the basic functionality of vhangup(2)
+growfiles
+
+        This program will grow a list of files.
+        Each file will grow by grow_incr before the same
+        file grows twice.  Each file is open and closed before next file is opened.
+
+pipe01  
+
+        Testcase to check the basic functionality of the pipe(2) syscall:
+        Check that both ends of the pipe (both file descriptors) are
+        available to a process opening the pipe.
+
+pipe05  
+
+        Check what happens when pipe is passed a bad file descriptor.
+
+pipe06  
+
+        Check what happens when the system runs out of pipes.
+
+pipe08  
+
+        Check that a SIGPIPE signal is generated when a write is
+        attempted on an empty pipe.
+
+pipe09  
+
+        Check that two processes can use the same pipe at the same time.
+
+pipe10  
+
+        Check that parent can open a pipe and have a child read from it
+
+pipe11  
+
+        Check if many children can read what is written to a pipe by the
+        parent.
+
+pipeio
+
+        This tool can be used to beat on system or named pipes.
+        See the help() function below for user information.
+
+        /ipc_stress/message_queue_test_01.c
+        /ipc_stress/pipe_test_01.c
+        /ipc_stress/semaphore_test_01.c
+        /ipc_stress/single_test_01.c
+
+proc01
+        Recursively reads all files within /proc filesystem.
+
+lftest
+        The purpose of this test is to verify the file size limitations of a filesystem.
+        It writes one buffer at a time and lseeks from the beginning of the file to the
+        end of the last write position.  The intent is to test lseek64.
+
+
+llseek01  
+
+        Verify that, llseek() call succeeds to set the file pointer position 
+        to an offset larger than file size. Also, verify that any attempt
+        to write to this location fails.
+
+llseek02  
+
+        Verify that,
+        1. llseek() returns -1 and sets errno to EINVAL, if the 'Whence' argument
+        is not a proper value.
+        2. llseek() returns -1 and sets errno to EBADF, if the file handle of
+        the specified file is not valid.
+
+lseek01
+
+        Basic test for lseek(2) 
+
+lseek02
+
+        Negative test for lseek(2) 
+
+lseek03
+
+        Negative test for lseek(2) whence
+
+lseek04
+
+        Negative test for lseek(2) of a fifo 
+
+lseek05
+
+        Negative test for lseek(2) of a pipe
+
+lseek06  
+
+        Verify that, lseek() call succeeds to set the file pointer position 
+        to less  than  or equal to the file size, when a file is opened for
+        read or write.
+
+lseek07  
+
+        Verify that, lseek() call succeeds to set the file pointer position
+        to more than the file size, when a file is opened for reading/writing.
+
+lseek08  
+
+        Verify that, lseek() call succeeds to set the file pointer position 
+        to the end of the file when 'whence' value set to SEEK_END and any
+        attempts to read from that position should fail.
+
+lseek09  
+
+        Verify that, lseek() call succeeds to set the file pointer position 
+        to the current specified location, when 'whence' value is set to
+        SEEK_CUR and the data read from the specified location should match
+        the expected data.
+
+lseek10  
+
+        Verify that,
+        1. lseek() returns -1 and sets errno to ESPIPE, if the file handle of
+        the specified file is associated with a pipe, socket, or  FIFO. 
+        2. lseek() returns -1 and sets errno to EINVAL, if the 'Whence' argument
+        is not a proper value.
+        3. lseek() returns -1 and sets errno to EBADF, if the file handle of
+        the specified file is not valid.
+
+rwtest
+
+        A wrapper for doio and iogen.
+
+doio 
+        a general purpose io initiator with system call and
+        write logging.  See doio.h for the structure which defines
+        what doio requests should look like.
+
+        Currently doio can handle read,write,reada,writea,ssread,
+        sswrite, and many varieties of listio requests.
+        For disk io, if the O_SSD flag is set doio will allocate
+        the appropriate amount of ssd and do the transfer - thus, doio
+        can handle all of the primitive types of file io.
+
+iogen 
+        A tool for generating file/sds io for a doio process
+
+pread01  
+
+        Verify the functionality of pread() by writing known data using pwrite()
+        to the file at various specified offsets and later read from the file from
+        various specified offsets, comparing the data read against the data 
+        written.
+
+pread02  
+
+        Verify that,
+        1) pread() fails when attempted to read from an unnamed pipe.
+        2) pread() fails if the specified offset position was invalid.
+
+
+pwrite01  
+
+        Verify the functionality of pwrite() by writing known data using pwrite()
+        to the file at various specified offsets and later read from the file from
+        various specified offsets, comparing the data written against the data
+        read using read().
+
+pwrite02  
+
+        Verify that,
+        1) pwrite() fails when attempted to write to an unnamed pipe.
+        2) pwrite() fails if the specified offset position was invalid.
+
+
+read01
+
+        Basic test for the read(2) system call
+
+read02  
+
+        test 1: Does read return -1 if file descriptor is not valid, check for EBADF
+
+        test 2: Check if read sets EISDIR, if the fd refers to a directory
+
+        test 3: Check if read sets EFAULT, if buf is -1.
+
+read03  
+
+        Testcase to check that read() sets errno to EAGAIN
+
+read04  
+
+        Testcase to check if read returns the number of bytes read correctly.
+
+
+readv01  
+
+        Testcase to check the basic functionality of the readv(2) system call.
+
+readv02  
+
+        Testcase to check the error conditions of the readv(2) system call.
+
+write01
+
+        Basic test for write(2) system call.
+
+write02  
+
+        Basic functionality test: does the return from write match the count
+        of the number of bytes written.
+
+
+write03  
+
+        Testcase to check that write(2) doesn't corrupt a file when it fails
+
+write04  
+
+        Testcase to check that write() sets errno to EAGAIN
+
+write05  
+
+        Check the return value, and errnos of write(2)
+        - when the file descriptor is invalid - EBADF
+        - when the buf parameter is invalid - EFAULT
+        - on an attempt to write to a pipe that is not open for reading - EPIPE
+
+
+writev01  
+
+        Testcase to check the basic functionality of writev(2) system call.
+
+
+writev02  
+
+        In these testcases, writev() is called with partially valid data 
+        to be written in a sparse file.
+
+
+writev03  
+
+        The testcases are written calling writev() with partially valid data
+        to overwrite the contents, to write in the beginning and to write in
+        the end of the file.
+
+writev04  
+
+        The testcases are written calling writev() with partially valid data
+        to overwrite the contents, to write in the beginning and to write in
+        the end of the file. This is same as writev03, but the length of
+        buffer used here is 8192 bytes.
+
+writev05  
+
+        These testcases are written to test writev() on sparse files. This
+        is same as writev02. But the initial write() with valid data is
+        done at the beginning of the file.
+
+disktest
+
+        Does repeated accesses to a filespec and optionally writes to, reads from,
+        and  verifies  the  data.  By default, disktest makes assumptions about
+        the running environment which allows for a quick start of IO generation.
+        However, Disktest has  a  large  number  of command line options which can
+        be used to adapt the test for a variety of uses including data integrity,
+        medium integrity, performance, and  simple application simulation.
+
+
+
+
+getdents01
+        get a directory entry
+
+getdents02
+        check that we get a failure with a bad file descriptor
+
+
+getdents03
+        check for an EINVAL error
+
+
+getdents04
+        check for an ENOTDIR error
+
+getdents05
+        check that we get a failure with a bad dirp address.
+process_stress
+        Spawn creates a tree
+        of processes with Dval depth and Bval breadth.  Each parent will spawn
+        Bval children.  Each child will store information about themselves
+        in shared memory.  The leaf nodes will communicate the existence
+        of one another through message queues, once each leaf node has
+        received communication from all of her siblings she will reduce
+        the semaphore count and exit.  Meanwhile all parents are waiting
+        to hear from their children through the use of semaphores.  When
+        the semaphore count reaches zero then the parent knows all the
+        children have talked to one another.  Locking of the connter semaphore
+        is provided by the use of another (binary) semaphore.
+
+
+
+
+sched_stress
+        Exports required environment variables and runs sched_driver
+sched_driver
+        This program uses system calls to change the 
+        priorities of the throughput measurement testcases.  
+        When real-time is in effect, priorities 50 through 64
+        are used.  (MAX_PRI and MIN_PRI)  When user-time     
+        (normal) is in effect, 0-14 (corresponding to nice()  
+        calls) is used.  The driver only keeps track of      
+        values from 50 to 64, and the testcases will scale   
+        them down to 0 to 14 when needed, to change the      
+        priority of a user-time process.                       
+
+time-schedule
+        This programme will determine the context switch 
+        (scheduling) overhead on a system. It takes into 
+        account SMP machines. True context switches are 
+        measured.
+trace_sched
+        This utility spawns N tasks, each task sets its priority 
+        by making a system call to the scheduler. The thread 
+        function reads the priority that the scheduler sets for 
+        this task and also reads from /proc the processor this 
+        task last executed on the information that is gathered 
+        by the thread function may be in real-time. Its only an 
+        approximation.         
+
+sched_getscheduler01  
+
+        Testcase to check sched_getscheduler() returns correct return value 
+
+sched_getscheduler02  
+
+        To check for the errno ESRCH
+
+
+sched_setscheduler01  
+
+        Testcase to test whether sched_setscheduler(2) sets the errnos
+        correctly.
+
+sched_setscheduler02  
+
+        Testcase to test whether sched_setscheduler(2) sets the errnos
+        correctly.
+
+
+sched_yield01  
+
+        Testcase to check that sched_yield returns correct values.
+
+
+nice01  
+
+        Verify that root can provide a negative value  to nice()
+        and hence root can decrease the nice value of the process
+        using nice() system call
+
+nice02  
+
+        Verify that any user can successfully increase the nice value of
+        the process by passing a higher increment value (> max. applicable limits)
+        to nice() system call.
+
+nice03  
+
+        Verify that any user can successfully increase the nice value of
+        the process by passing an increment value (< max. applicable limits) to 
+        nice() system call.
+
+nice04  
+
+        Verify that, nice(2) fails when, a non-root user attempts to increase
+        the priority of a process by specifying a negative increment value.
+
+nice05
+
+        Basic test for nice(2) 
+
+
+poll01  
+
+        Verify that valid open file descriptor must be provided to poll() to
+        succeed.
+
+select01
+
+        Basic test for the select(2) system call to a fd of regular file with no I/O 
+        and small timeout 
+
+select02
+
+        Basic test for the select(2) system call to fd of system pipe with no I/O 
+        and small timeout 
+
+select03
+
+        Basic test for the select(2) system call to fd of a named-pipe (FIFO) 
+
+select04  
+
+        Verify that select(2) returns immediately (does not block) if the
+        timeout value is zero.
+
+select05  
+
+        Verify that select(2) fails when one or more of the file descriptor sets
+        specify a file descriptor which is not valid.
+
+select06  
+
+        Verify that select(2) fails when a signal is delivered before any of the
+        selected events occur and before the timeout interval expires.
+
+select07  
+
+        Verify that select(2) fails when an invalid timeout interval is specified.
+
+select08  
+
+        Verify the functionality of select(2) by passing non-null writefds
+        which points to a regular file, pipes or FIFO's.
+
+select09  
+
+        Verify the functionality of select(2) by passing non-null readfds
+        which points to a regular file, pipes or FIFO's.
+
+select10 
+
+        Verify that a successful call to select() shall return the desired 
+        number of modified descriptors for which bits are set in the bit masks, 
+        where descriptors points to a regular file, pipes or FIFO's.
+sem01
+
+        Creates a semaphore and two processes.  The processes
+        each go through a loop where they semdown, delay for a
+        random amount of time, and semup, so they will almost
+        always be fighting for control of the semaphore.
+
+sem02
+        The application creates several threads using pthread_create().
+        One thread performs a semop() with the SEM_UNDO flag set. The
+        change in semaphore value performed by that semop should be
+        "undone" only when the last pthread exits.
+
+
+semctl01  
+
+        test the 10 possible semctl() commands
+
+semctl02  
+
+        test for EACCES error
+
+semctl03  
+
+        test for EINVAL and EFAULT errors
+
+semctl04 
+
+        test for EPERM error
+
+
+semctl05
+
+        test for ERANGE error
+
+semget01
+
+        test that semget() correctly creates a semaphore set
+
+semget02 
+
+        test for EACCES and EEXIST errors
+
+semget03 
+
+        test for ENOENT error
+
+semget05 
+
+        test for ENOSPC error
+
+semget06
+
+        test for EINVAL error
+
+semop01 
+
+        test that semop() basic functionality is correct
+
+semop02
+
+        test for E2BIG, EACCES, EFAULT and EINVAL errors
+
+semop03
+
+        test for EFBIG error
+
+semop04
+
+        test for EAGAIN error
+
+semop05
+
+        test for EINTR and EIDRM errors
+
+
+shmat01
+        test that shmat() works correctly
+
+shmat02
+        check for EINVAL and EACCES errors
+
+
+shmat03
+        test for EACCES error
+
+
+shmctl01
+        test the IPC_STAT, IPC_SET and IPC_RMID commands as
+        they are used with shmctl()
+
+
+shmctl02
+        check for EACCES, EFAULT and EINVAL errors
+
+
+shmctl03
+        check for EACCES, and EPERM errors
+
+
+shmdt01
+        check that shared memory is detached correctly
+
+
+shmdt02
+        check for EINVAL error
+
+
+shmget01
+        test that shmget() correctly creates a shared memory segment
+
+
+shmget02
+        check for ENOENT, EEXIST and EINVAL errors
+
+
+shmget03
+        test for ENOSPC error
+
+
+shmget04
+        test for EACCES error
+
+
+shmget05
+        test for EACCES error
+shmat1
+
+        Test the LINUX memory manager. The program is aimed at
+        stressing the memory manager by repeated shmat/write/read/
+        shmatd of file/memory of random size (maximum 1000 * 4096)
+        done by multiple processes.
+
+shm_test
+
+        This program is designed to stress the Memory management sub -
+        system of Linux. This program will spawn multiple pairs of
+        reader and writer threads. One thread will create the shared
+        segment of random size and write to this memory, the other
+        pair will read from this memory.
+
+sigaction01  
+
+        Test some features of sigaction (see below for more details)
+
+
+sigaction02  
+
+        Testcase to check the basic errnos set by the sigaction(2) syscall.
+
+
+sigaltstack01  
+
+        Send a signal using the main stack. While executing the signal handler
+        compare a variable's address lying on the main stack with the stack
+        boundaries returned by sigaltstack().
+
+
+sigaltstack02  
+
+        Verify that,
+        1. sigaltstack() fails and sets errno to EINVAL when "ss_flags" field
+        pointed to by 'ss' contains invalid flags.
+        2. sigaltstack() fails and sets errno to ENOMEM when the size of alternate
+        stack area is less than MINSIGSTKSZ.
+
+sighold02
+
+        Basic test for the sighold02(2) system call. 
+
+
+signal01
+        set the signal handler to our own function
+
+
+signal02 
+        Test that we get an error using illegal signals
+
+signal03
+
+        Boundary value and other invalid value checking of signal setup and signal 
+        sending. 
+
+
+signal04 
+        restore signals to default behavior
+
+
+signal05 
+        set signals to be ignored
+
+
+sigprocmask01  
+
+        Verify that sigprocmask() succeeds to examine and change the calling
+        process's signal mask. 
+        Also, verify that sigpending() succeeds to store signal mask that are
+        blocked from delivery and pending for the calling process.
+
+sigrelse01
+
+        Basic test for the sigrelse(2) system call. 
+
+sigsuspend01  
+
+        Verify that sigsuspend() succeeds to change process's current signal
+        mask with the specified signal mask and suspends the process execution
+        until the delivery of a signal.
+kill01  
+
+        Test case to check the basic functionality of kill().
+
+kill02
+
+        Sending a signal to processes with the same process group ID
+
+kill03  
+
+        Test case to check that kill fails when given an invalid signal.
+
+kill04  
+
+        Test case to check that kill() fails when passed a non-existent pid.
+
+kill05  
+
+        Test case to check that kill() fails when passed a pid owned by another
+        user.
+
+kill06  
+
+        Test case to check the basic functionality of kill() when killing an
+        entire process group with a negative pid.
+
+kill07  
+
+        Test case to check that SIGKILL can not be caught.
+
+kill08  
+
+        Test case to check the basic functionality of kill() when kill an
+        entire process group.
+
+kill09
+        Basic test for kill(2)
+
+kill10
+        Signal flooding test.
+
+
+mtest01
+        mallocs memory <chunksize> at a time until malloc fails.
+mallocstress
+
+        This program is designed to stress the VMM by doing repeated  */
+        mallocs and frees, with out using the swap space. This is     */
+        achieved by spawning N threads with repeatedly malloc and free*/
+        a memory of size M. The stress can be increased by increasing */
+        the number of repetitions over the default number using the   */
+        -l [num] option.
+
+clisrv
+
+        Sender: Read contents of data file. Write each line to socket, then
+        read line back from socket and write to standard output.      
+        Receiver: Read a stream socket one line at a time and write each line
+        back to the sender.                                       
+        Usage:       pthcli [port number]                 
+                            
+
+socket01  
+
+        Verify that socket() returns the proper errno for various failure cases
+
+
+socketpair01  
+
+        Verify that socketpair() returns the proper errno for various failure cases
+
+
+sockioctl01  
+
+        Verify that ioctl() on sockets returns the proper errno for various
+        failure cases
+
+connect01  
+
+        Verify that connect() returns the proper errno for various failure cases
+
+getpeername01
+
+        Verify that getpeername() returns the proper errno for various failure cases
+
+
+getsockname01      
+
+        Verify that getsockname() returns the proper errno for various failure cases
+
+getsockopt01       
+
+        Verify that getsockopt() returns the proper errno for various failure cases
+
+listen01
+
+        Verify that listen() returns the proper errno for various failure cases
+
+accept01
+
+        Verify that accept() returns the proper errno for various failure cases
+
+bind01
+
+        Verify that bind() returns the proper errno for various failure cases
+
+
+recv01  
+
+        Verify that recv() returns the proper errno for various failure cases
+
+
+recvfrom01  
+
+        Verify that recvfrom() returns the proper errno for various failure cases
+
+
+recvmsg01  
+
+        Verify that recvmsg() returns the proper errno for various failure cases
+
+send01
+
+        Verify that send() returns the proper errno for various failure cases
+
+sendmsg01
+
+        Verify that sendmsg() returns the proper errno for various failure cases
+sendto01
+
+        Verify that sendto() returns the proper errno for various failure cases
+
+setsockopt01  
+
+        Verify that setsockopt() returns the proper errno for various failure cases
+
+
+fstat01
+
+        Basic test for fstat(2)
+
+fstat02  
+
+        Verify that, fstat(2) succeeds to get the status of a file and fills
+        the stat structure elements though file pointed to by file descriptor
+        not opened for reading.
+
+fstat03  
+
+        Verify that, fstat(2) returns -1 and sets errno to EBADF if the file 
+        pointed to by file descriptor is not valid.
+
+fstat04
+
+        Verify that, fstat(2) succeeds to get the status of a file pointed by
+        file descriptor and fills the stat structure elements.
+
+
+fstatfs01
+
+        Basic test for fstatfs(2)
+
+fstatfs02  
+
+        Testcase to check fstatfs() sets errno correctly.
+
+lstat01  
+
+        Verify that, lstat(2) succeeds to get the status of a file pointed to by
+        symlink and fills the stat structure elements.
+
+lstat02
+
+        Basic test for lstat(2) 
+
+lstat03  
+
+        Verify that,
+        1) lstat(2) returns -1 and sets errno to EACCES if search permission is
+        denied on a component of the path prefix.
+        2) lstat(2) returns -1 and sets errno to ENOENT if the specified file
+        does not exists or empty string.
+        3) lstat(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        4) lstat(2) returns -1 and sets errno to ENAMETOOLONG if the pathname
+        component is too long.
+        5) lstat(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname is not a directory.
+
+stat01  
+
+        Verify that, stat(2) succeeds to get the status of a file and fills the
+        stat structure elements.
+
+stat02  
+
+        Verify that, stat(2) succeeds to get the status of a file and fills the
+        stat structure elements though process doesn't have read access to the
+        file.
+
+
+stat03  
+
+        Verify that,
+        1) stat(2) returns -1 and sets errno to EACCES if search permission is
+        denied on a component of the path prefix.
+        2) stat(2) returns -1 and sets errno to ENOENT if the specified file
+        does not exists or empty string.
+        3) stat(2) returns -1 and sets errno to EFAULT if pathname points
+        outside user's accessible address space.
+        4) stat(2) returns -1 and sets errno to ENAMETOOLONG if the pathname
+        component is too long.
+        5) stat(2) returns -1 and sets errno to ENOTDIR if the directory
+        component in pathname is not a directory.
+
+stat05
+
+        Basic test for the stat05(2) system call. 
+
+statfs01
+
+        Basic test for the statfs(2) system call. 
+
+statfs02  
+
+        Testcase to check that statfs(2) sets errno correctly.
+
+
+read01
+
+        Basic test for the read(2) system call
+
+read02  
+
+        test 1: Does read return -1 if file descriptor is not valid, check for EBADF
+
+        test 2: Check if read sets EISDIR, if the fd refers to a directory
+
+        test 3: Check if read sets EFAULT, if buf is -1.
+
+read03  
+
+        Testcase to check that read() sets errno to EAGAIN
+
+read04  
+
+        Testcase to check if read returns the number of bytes read correctly.
+
+umask01
+
+        Basic test for the umask(2) system call. 
+
+umask02  
+
+        Check that umask changes the mask, and that the previous
+        value of the mask is returned correctly for each value.
+
+umask03  
+
+        Check that umask changes the mask, and that the previous
+        value of the mask is returned correctly for each value.
+
+
+
+getgroups01
+
+        Getgroups system call critical test 
+
+getgroups02
+
+        Basic test for getgroups(2) 
+
+getgroups03  
+
+        Verify that, getgroups() system call gets the supplementary group IDs
+        of the calling process.
+
+getgroups04  
+
+        Verify that,
+        getgroups() fails with -1 and sets errno to EINVAL if the size
+        argument value is -ve.
+
+gethostname01
+
+        Basic test for gethostname(2)
+
+
+getpgid01
+
+        Testcase to check the basic functionality of getpgid().
+
+getpgid02
+
+        Testcase to check the basic functionality of getpgid().
+
+getpgrp01
+        Basic test for getpgrp(2)
+
+
+getpriority01  
+
+        Verify that getpriority() succeeds get the scheduling priority of 
+        the current process, process group or user.
+
+
+getpriority02  
+
+        Verify that,
+        1) getpriority() sets errno to ESRCH  if no process was located
+        was located for 'which' and 'who' arguments.
+        2) getpriority() sets errno to EINVAL if 'which' argument was
+        not one of PRIO_PROCESS, PRIO_PGRP, or PRIO_USER.
+
+getresgid01  
+
+        Verify that getresgid() will be successful to get the real, effective
+        and saved user id of the calling process.
+
+getresgid02  
+
+        Verify that getresgid() will be successful to get the real, effective
+        and saved user ids after calling process invokes setregid() to change
+        the effective/saved gids to that of specified user.
+
+getresgid03  
+
+        Verify that getresgid() will be successful to get the real, effective
+        and saved user ids after calling process invokes setresgid() to change
+        the effective gid to that of specified user.
+
+
+getresuid01  
+
+        Verify that getresuid() will be successful to get the real, effective
+        and saved user id of the calling process.
+
+getresuid02  
+
+        Verify that getresuid() will be successful to get the real, effective
+        and saved user ids after calling process invokes setreuid() to change
+        the effective/saved uids to that of specified user.
+
+getresuid03  
+
+        Verify that getresuid() will be successful to get the real, effective
+        and saved user ids after calling process invokes setresuid() to change
+        the effective uid to that of specified user.
+
+
+getsid01  
+
+        call getsid() and make sure it succeeds
+
+getsid02  
+
+        call getsid() with an invalid PID to produce a failure
+
+
+setfsgid01  
+
+        Testcase to check the basic functionality of setfsgid(2) system
+        call.
+
+setfsuid01  
+
+        Testcase to test the basic functionality of the setfsuid(2) system
+        call.
+
+
+setgid01
+
+        Basic test for the setgid(2) system call. 
+
+setgid02
+
+        Testcase to ensure that the setgid() system call sets errno to EPERM
+
+
+setgroups01
+
+        Basic test for the setgroups(2) system call. 
+
+setgroups02  
+
+        Verify that,
+        1. setgroups() fails with -1 and sets errno to EINVAL if the size
+        argument value is > NGROUPS
+        2. setgroups() fails with -1 and sets errno to EPERM if the
+        calling process is not super-user.
+
+setgroups03  
+
+        Verify that, only root process can invoke setgroups() system call to
+        set the supplementary group IDs of the process.
+
+
+setpgid01               
+
+        Basic test for setpgid(2) system call. 
+
+setpgid02  
+
+        Testcase to check that setpgid() sets errno correctly.
+
+setpgid03  
+
+        Test to check the error and trivial conditions in setpgid system call
+
+setpriority01  
+
+        set the priority for the test process lower.
+
+setpriority02  
+
+        test for an expected failure by trying to raise
+        the priority for the test process while not having
+        permissions to do so.
+
+setpriority03  
+
+        test for an expected failure by using an invalid
+        PRIO value
+        setpriority04  
+
+setpriority04
+        test for an expected failure by using an invalid
+        process id
+
+
+setpriority05 
+        test for an expected failure by trying to change
+        a process with an ID that is different from the
+        test process
+
+setregid01       
+
+        Basic test for the setregid(2) system call. 
+
+setregid02  
+
+        Test that setregid() fails and sets the proper errno values when a
+        non-root user attempts to change the real or effective group id to a 
+        value other than the current gid or the current effective gid. 
+
+setregid03  
+
+        Test setregid() when executed by a non-root user.
+
+setregid04  
+
+        Test setregid() when executed by root.
+
+setresuid01  
+
+        Test setresuid() when executed by root.
+
+setresuid02  
+
+        Test that a non-root user can change the real, effective and saved
+        uid values through the setresuid system call.
+
+
+setresuid03  
+
+        Test that the setresuid system call sets the proper errno
+        values when a non-root user attempts to change the real, effective or
+        saved uid to a value other than one of the current uid, the current
+        effective uid of the current saved uid.  Also verify that setresuid
+        fails if an invalid uid value is given.
+
+setreuid01              
+
+        Basic test for the setreuid(2) system call. 
+
+setreuid02  
+
+        Test setreuid() when executed by root.
+
+setreuid03  
+
+        Test setreuid() when executed by an unprivileged user.
+
+
+setreuid04  
+
+        Test that root can change the real and effective uid to an
+        unprivileged user.
+
+setreuid05  
+
+        Test the setreuid() feature, verifying the role of the saved-set-uid
+        and setreuid's effect on it.
+
+setreuid06  
+
+        Test that EINVAL is set when setreuid is given an invalid user id.
+
+setrlimit01  
+
+        Testcase to check the basic functionality of the setrlimit system call.
+
+
+setrlimit02  
+
+        Testcase to test the different errnos set by setrlimit(2) system call.
+
+setrlimit03  
+
+        Test for EPERM when the super-user tries to increase RLIMIT_NOFILE
+        beyond the system limit.
+
+setsid01  
+
+        Test to check the error and trivial conditions in setsid system call
+
+setuid01
+
+        Basic test for the setuid(2) system call. 
+
+setuid02
+
+        Basic test for the setuid(2) system call as root. 
+
+setuid03  
+
+        Test to check the error and trivial conditions in setuid
+
+fs_perms
+
+        Regression test for Linux filesystem permissions.
+uname01
+
+        Basic test for the uname(2) system call.  
+
+uname02  
+
+        Call uname() with an invalid address to produce a failure
+
+uname03  
+
+        Call uname() and make sure it succeeds
+sysctl01  
+
+        Testcase for testing the basic functionality of sysctl(2) system call.
+        This testcase attempts to read the kernel parameters using
+        sysctl({CTL_KERN, KERN_ }, ...) and compares it with the known
+        values.
+
+sysctl03  
+
+        Testcase to check that sysctl(2) sets errno to EPERM correctly.
+
+
+sysctl04  
+
+        Testcase to check that sysctl(2) sets errno to ENOTDIR
+
+
+sysctl05  
+
+        Testcase to check that sysctl(2) sets errno to EFAULT
+
+time01
+
+        Basic test for the time(2) system call. 
+
+
+time02  
+
+        Verify that time(2) returns the value of time in seconds since
+        the Epoch and stores this value in the memory pointed to by the parameter.
+
+times01
+
+        Basic test for the times(2) system call. 
+
+times02  
+
+        Testcase to test that times() sets errno correctly
+
+times03  
+
+        Testcase to check the basic functionality of the times() system call.
+
+utime01  
+
+        Verify that the system call utime() successfully sets the modification
+        and access times of a file to the current time, if the times argument
+        is null, and the user ID of the process is "root".
+
+utime02  
+
+        Verify that the system call utime() successfully sets the modification
+        and access times of a file to the current time, under the following
+        constraints,
+        - The times argument is null.
+        - The user ID of the process is not "root".
+        - The file is owned by the user ID of the process.
+
+utime03  
+
+        Verify that the system call utime() successfully sets the modification
+        and access times of a file to the current time, under the following
+        constraints,
+        - The times argument is null.
+        - The user ID of the process is not "root".
+        - The file is not owned by the user ID of the process.
+        - The user ID of the process has write access to the file.
+
+
+utime04  
+
+        Verify that the system call utime() successfully sets the modification
+        and access times of a file to the time specified by times argument, if
+        the times argument is not null, and the user ID of the process is "root".
+
+
+utime05  
+
+        Verify that the system call utime() successfully sets the modification
+        and access times of a file to the value specified by the times argument
+        under the following constraints,
+        - The times argument is not null,
+        - The user ID of the process is not "root".
+        - The file is owned by the user ID of the process.
+
+
+utime06  
+
+        1. Verify that the system call utime() fails to set the modification
+        and access times of a file to the current time, under the following
+        constraints,
+        - The times argument is null.
+        - The user ID of the process is not "root".
+        - The file is not owned by the user ID of the process.
+        - The user ID of the process does not have write access to the
+        file.
+        2. Verify that the system call utime() fails to set the modification
+        and access times of a file if the specified file doesn't exist.
+
+settimeofday01  
+
+        Testcase to check the basic functionality of settimeofday().
+
+
+settimeofday02  
+
+        Testcase to check that settimeofday() sets errnos correctly.
+
+stime01  
+
+        Verify that the system call stime() successfully sets the system's idea
+        of data and time if invoked by "root" user.
+
+stime02  
+
+        Verify that the system call stime() fails to set the system's idea
+        of data and time if invoked by "non-root" user.
+
+gettimeofday01     
+
+        Testcase to check that gettimeofday(2) sets errno to EFAULT.
+
+
+
+alarm01         
+
+        Basic test for alarm(2). 
+
+alarm02
+
+        Boundary Value Test for alarm(2).
+
+alarm03
+
+        Alarm(2) cleared by a fork.
+
+alarm04  
+
+        Check that when an alarm request is made, the signal SIGALRM is received
+        even after the process has done an exec().
+
+alarm05  
+
+        Check the functionality of the Alarm system call when the time input
+        parameter is non zero.
+
+alarm06  
+
+        Check the functionality of the Alarm system call when the time input
+        parameter is zero.
+
+alarm07  
+
+        Check the functionality of the alarm() when the time input
+        parameter is non-zero and the process does a fork.
+
+getegid01
+
+        Basic test for getegid(2) 
+
+
+geteuid01
+
+        Basic test for geteuid(2) 
+
+
+getgid01
+
+        Basic test for getgid(2) 
+
+getgid02  
+
+        Testcase to check the basic functionality of getgid().
+
+getgid03  
+
+        Testcase to check the basic functionality of getegid().
+
+
+getpid01
+
+        Basic test for getpid(2) 
+
+
+getpid02  
+
+        Verify that getpid() system call gets the process ID of the of the
+        calling process.
+
+
+getppid01  
+
+        Testcase to check the basic functionality of the getppid() syscall.
+
+
+getuid01
+
+        Basic test for getuid(2)
+
+getuid02  
+
+        Testcase to check the basic functionality of the geteuid() system call.
+
+getuid03  
+
+        Testcase to check the basic functionality of the getuid() system call.
+
+nanosleep01  
+
+        Verify that nanosleep() will be successful to suspend the execution
+        of a process for a specified time.
+
+nanosleep02  
+
+        Verify that nanosleep() will be successful to suspend the execution
+        of a process, returns after the receipt of a signal and writes the
+        remaining sleep time into the structure.
+
+nanosleep03  
+
+        Verify that nanosleep() will fail to suspend the execution
+        of a process for a specified time if interrupted by a non-blocked signal.
+
+nanosleep04  
+
+        Verify that nanosleep() will fail to suspend the execution
+        of a process if the specified pause time is invalid.
+