EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_posix.py

"Test posix functions"\r
\r
from test import test_support\r
\r
# Skip these tests if there is no posix module.\r
posix = test_support.import_module('posix')\r
\r
import errno\r
import sys\r
import time\r
import os\r
import pwd\r
import shutil\r
import sys\r
import unittest\r
import warnings\r
\r
\r
warnings.filterwarnings('ignore', '.* potential security risk .*',\r
                        RuntimeWarning)\r
\r
class PosixTester(unittest.TestCase):\r
\r
    def setUp(self):\r
        # create empty file\r
        fp = open(test_support.TESTFN, 'w+')\r
        fp.close()\r
\r
    def tearDown(self):\r
        os.unlink(test_support.TESTFN)\r
\r
    def testNoArgFunctions(self):\r
        # test posix functions which take no arguments and have\r
        # no side-effects which we need to cleanup (e.g., fork, wait, abort)\r
        NO_ARG_FUNCTIONS = [ "ctermid", "getcwd", "getcwdu", "uname",\r
                             "times", "getloadavg", "tmpnam",\r
                             "getegid", "geteuid", "getgid", "getgroups",\r
                             "getpid", "getpgrp", "getppid", "getuid",\r
                           ]\r
\r
        with warnings.catch_warnings():\r
            warnings.filterwarnings("ignore", "", DeprecationWarning)\r
            for name in NO_ARG_FUNCTIONS:\r
                posix_func = getattr(posix, name, None)\r
                if posix_func is not None:\r
                    posix_func()\r
                    self.assertRaises(TypeError, posix_func, 1)\r
\r
    if hasattr(posix, 'getresuid'):\r
        def test_getresuid(self):\r
            user_ids = posix.getresuid()\r
            self.assertEqual(len(user_ids), 3)\r
            for val in user_ids:\r
                self.assertGreaterEqual(val, 0)\r
\r
    if hasattr(posix, 'getresgid'):\r
        def test_getresgid(self):\r
            group_ids = posix.getresgid()\r
            self.assertEqual(len(group_ids), 3)\r
            for val in group_ids:\r
                self.assertGreaterEqual(val, 0)\r
\r
    if hasattr(posix, 'setresuid'):\r
        def test_setresuid(self):\r
            current_user_ids = posix.getresuid()\r
            self.assertIsNone(posix.setresuid(*current_user_ids))\r
            # -1 means don't change that value.\r
            self.assertIsNone(posix.setresuid(-1, -1, -1))\r
\r
        def test_setresuid_exception(self):\r
            # Don't do this test if someone is silly enough to run us as root.\r
            current_user_ids = posix.getresuid()\r
            if 0 not in current_user_ids:\r
                new_user_ids = (current_user_ids[0]+1, -1, -1)\r
                self.assertRaises(OSError, posix.setresuid, *new_user_ids)\r
\r
    if hasattr(posix, 'setresgid'):\r
        def test_setresgid(self):\r
            current_group_ids = posix.getresgid()\r
            self.assertIsNone(posix.setresgid(*current_group_ids))\r
            # -1 means don't change that value.\r
            self.assertIsNone(posix.setresgid(-1, -1, -1))\r
\r
        def test_setresgid_exception(self):\r
            # Don't do this test if someone is silly enough to run us as root.\r
            current_group_ids = posix.getresgid()\r
            if 0 not in current_group_ids:\r
                new_group_ids = (current_group_ids[0]+1, -1, -1)\r
                self.assertRaises(OSError, posix.setresgid, *new_group_ids)\r
\r
    @unittest.skipUnless(hasattr(posix, 'initgroups'),\r
                         "test needs os.initgroups()")\r
    def test_initgroups(self):\r
        # It takes a string and an integer; check that it raises a TypeError\r
        # for other argument lists.\r
        self.assertRaises(TypeError, posix.initgroups)\r
        self.assertRaises(TypeError, posix.initgroups, None)\r
        self.assertRaises(TypeError, posix.initgroups, 3, "foo")\r
        self.assertRaises(TypeError, posix.initgroups, "foo", 3, object())\r
\r
        # If a non-privileged user invokes it, it should fail with OSError\r
        # EPERM.\r
        if os.getuid() != 0:\r
            name = pwd.getpwuid(posix.getuid()).pw_name\r
            try:\r
                posix.initgroups(name, 13)\r
            except OSError as e:\r
                self.assertEqual(e.errno, errno.EPERM)\r
            else:\r
                self.fail("Expected OSError to be raised by initgroups")\r
\r
    def test_statvfs(self):\r
        if hasattr(posix, 'statvfs'):\r
            self.assertTrue(posix.statvfs(os.curdir))\r
\r
    def test_fstatvfs(self):\r
        if hasattr(posix, 'fstatvfs'):\r
            fp = open(test_support.TESTFN)\r
            try:\r
                self.assertTrue(posix.fstatvfs(fp.fileno()))\r
            finally:\r
                fp.close()\r
\r
    def test_ftruncate(self):\r
        if hasattr(posix, 'ftruncate'):\r
            fp = open(test_support.TESTFN, 'w+')\r
            try:\r
                # we need to have some data to truncate\r
                fp.write('test')\r
                fp.flush()\r
                posix.ftruncate(fp.fileno(), 0)\r
            finally:\r
                fp.close()\r
\r
    def test_dup(self):\r
        if hasattr(posix, 'dup'):\r
            fp = open(test_support.TESTFN)\r
            try:\r
                fd = posix.dup(fp.fileno())\r
                self.assertIsInstance(fd, int)\r
                os.close(fd)\r
            finally:\r
                fp.close()\r
\r
    def test_confstr(self):\r
        if hasattr(posix, 'confstr'):\r
            self.assertRaises(ValueError, posix.confstr, "CS_garbage")\r
            self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)\r
\r
    def test_dup2(self):\r
        if hasattr(posix, 'dup2'):\r
            fp1 = open(test_support.TESTFN)\r
            fp2 = open(test_support.TESTFN)\r
            try:\r
                posix.dup2(fp1.fileno(), fp2.fileno())\r
            finally:\r
                fp1.close()\r
                fp2.close()\r
\r
    def fdopen_helper(self, *args):\r
        fd = os.open(test_support.TESTFN, os.O_RDONLY)\r
        fp2 = posix.fdopen(fd, *args)\r
        fp2.close()\r
\r
    def test_fdopen(self):\r
        if hasattr(posix, 'fdopen'):\r
            self.fdopen_helper()\r
            self.fdopen_helper('r')\r
            self.fdopen_helper('r', 100)\r
\r
    def test_osexlock(self):\r
        if hasattr(posix, "O_EXLOCK"):\r
            fd = os.open(test_support.TESTFN,\r
                         os.O_WRONLY|os.O_EXLOCK|os.O_CREAT)\r
            self.assertRaises(OSError, os.open, test_support.TESTFN,\r
                              os.O_WRONLY|os.O_EXLOCK|os.O_NONBLOCK)\r
            os.close(fd)\r
\r
            if hasattr(posix, "O_SHLOCK"):\r
                fd = os.open(test_support.TESTFN,\r
                             os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)\r
                self.assertRaises(OSError, os.open, test_support.TESTFN,\r
                                  os.O_WRONLY|os.O_EXLOCK|os.O_NONBLOCK)\r
                os.close(fd)\r
\r
    def test_osshlock(self):\r
        if hasattr(posix, "O_SHLOCK"):\r
            fd1 = os.open(test_support.TESTFN,\r
                         os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)\r
            fd2 = os.open(test_support.TESTFN,\r
                          os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)\r
            os.close(fd2)\r
            os.close(fd1)\r
\r
            if hasattr(posix, "O_EXLOCK"):\r
                fd = os.open(test_support.TESTFN,\r
                             os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)\r
                self.assertRaises(OSError, os.open, test_support.TESTFN,\r
                                  os.O_RDONLY|os.O_EXLOCK|os.O_NONBLOCK)\r
                os.close(fd)\r
\r
    def test_fstat(self):\r
        if hasattr(posix, 'fstat'):\r
            fp = open(test_support.TESTFN)\r
            try:\r
                self.assertTrue(posix.fstat(fp.fileno()))\r
            finally:\r
                fp.close()\r
\r
    def test_stat(self):\r
        if hasattr(posix, 'stat'):\r
            self.assertTrue(posix.stat(test_support.TESTFN))\r
\r
    def _test_all_chown_common(self, chown_func, first_param):\r
        """Common code for chown, fchown and lchown tests."""\r
        if os.getuid() == 0:\r
            try:\r
                # Many linux distros have a nfsnobody user as MAX_UID-2\r
                # that makes a good test case for signedness issues.\r
                #   http://bugs.python.org/issue1747858\r
                # This part of the test only runs when run as root.\r
                # Only scary people run their tests as root.\r
                ent = pwd.getpwnam('nfsnobody')\r
                chown_func(first_param, ent.pw_uid, ent.pw_gid)\r
            except KeyError:\r
                pass\r
        else:\r
            # non-root cannot chown to root, raises OSError\r
            self.assertRaises(OSError, chown_func,\r
                              first_param, 0, 0)\r
\r
        # test a successful chown call\r
        chown_func(first_param, os.getuid(), os.getgid())\r
\r
    @unittest.skipUnless(hasattr(posix, 'chown'), "test needs os.chown()")\r
    def test_chown(self):\r
        # raise an OSError if the file does not exist\r
        os.unlink(test_support.TESTFN)\r
        self.assertRaises(OSError, posix.chown, test_support.TESTFN, -1, -1)\r
\r
        # re-create the file\r
        open(test_support.TESTFN, 'w').close()\r
        self._test_all_chown_common(posix.chown, test_support.TESTFN)\r
\r
    @unittest.skipUnless(hasattr(posix, 'fchown'), "test needs os.fchown()")\r
    def test_fchown(self):\r
        os.unlink(test_support.TESTFN)\r
\r
        # re-create the file\r
        test_file = open(test_support.TESTFN, 'w')\r
        try:\r
            fd = test_file.fileno()\r
            self._test_all_chown_common(posix.fchown, fd)\r
        finally:\r
            test_file.close()\r
\r
    @unittest.skipUnless(hasattr(posix, 'lchown'), "test needs os.lchown()")\r
    def test_lchown(self):\r
        os.unlink(test_support.TESTFN)\r
        # create a symlink\r
        os.symlink('/tmp/dummy-symlink-target', test_support.TESTFN)\r
        self._test_all_chown_common(posix.lchown, test_support.TESTFN)\r
\r
    def test_chdir(self):\r
        if hasattr(posix, 'chdir'):\r
            posix.chdir(os.curdir)\r
            self.assertRaises(OSError, posix.chdir, test_support.TESTFN)\r
\r
    def test_lsdir(self):\r
        if hasattr(posix, 'lsdir'):\r
            self.assertIn(test_support.TESTFN, posix.lsdir(os.curdir))\r
\r
    def test_access(self):\r
        if hasattr(posix, 'access'):\r
            self.assertTrue(posix.access(test_support.TESTFN, os.R_OK))\r
\r
    def test_umask(self):\r
        if hasattr(posix, 'umask'):\r
            old_mask = posix.umask(0)\r
            self.assertIsInstance(old_mask, int)\r
            posix.umask(old_mask)\r
\r
    def test_strerror(self):\r
        if hasattr(posix, 'strerror'):\r
            self.assertTrue(posix.strerror(0))\r
\r
    def test_pipe(self):\r
        if hasattr(posix, 'pipe'):\r
            reader, writer = posix.pipe()\r
            os.close(reader)\r
            os.close(writer)\r
\r
    def test_tempnam(self):\r
        if hasattr(posix, 'tempnam'):\r
            with warnings.catch_warnings():\r
                warnings.filterwarnings("ignore", "tempnam", DeprecationWarning)\r
                self.assertTrue(posix.tempnam())\r
                self.assertTrue(posix.tempnam(os.curdir))\r
                self.assertTrue(posix.tempnam(os.curdir, 'blah'))\r
\r
    def test_tmpfile(self):\r
        if hasattr(posix, 'tmpfile'):\r
            with warnings.catch_warnings():\r
                warnings.filterwarnings("ignore", "tmpfile", DeprecationWarning)\r
                fp = posix.tmpfile()\r
                fp.close()\r
\r
    def test_utime(self):\r
        if hasattr(posix, 'utime'):\r
            now = time.time()\r
            posix.utime(test_support.TESTFN, None)\r
            self.assertRaises(TypeError, posix.utime, test_support.TESTFN, (None, None))\r
            self.assertRaises(TypeError, posix.utime, test_support.TESTFN, (now, None))\r
            self.assertRaises(TypeError, posix.utime, test_support.TESTFN, (None, now))\r
            posix.utime(test_support.TESTFN, (int(now), int(now)))\r
            posix.utime(test_support.TESTFN, (now, now))\r
\r
    def test_chflags(self):\r
        if hasattr(posix, 'chflags'):\r
            st = os.stat(test_support.TESTFN)\r
            if hasattr(st, 'st_flags'):\r
                posix.chflags(test_support.TESTFN, st.st_flags)\r
\r
    def test_lchflags(self):\r
        if hasattr(posix, 'lchflags'):\r
            st = os.stat(test_support.TESTFN)\r
            if hasattr(st, 'st_flags'):\r
                posix.lchflags(test_support.TESTFN, st.st_flags)\r
\r
    def test_getcwd_long_pathnames(self):\r
        if hasattr(posix, 'getcwd'):\r
            dirname = 'getcwd-test-directory-0123456789abcdef-01234567890abcdef'\r
            curdir = os.getcwd()\r
            base_path = os.path.abspath(test_support.TESTFN) + '.getcwd'\r
\r
            try:\r
                os.mkdir(base_path)\r
                os.chdir(base_path)\r
            except:\r
#               Just returning nothing instead of the SkipTest exception,\r
#               because the test results in Error in that case.\r
#               Is that ok?\r
#                raise unittest.SkipTest, "cannot create directory for testing"\r
                return\r
\r
            try:\r
                def _create_and_do_getcwd(dirname, current_path_length = 0):\r
                    try:\r
                        os.mkdir(dirname)\r
                    except:\r
                        raise unittest.SkipTest, "mkdir cannot create directory sufficiently deep for getcwd test"\r
\r
                    os.chdir(dirname)\r
                    try:\r
                        os.getcwd()\r
                        if current_path_length < 4099:\r
                            _create_and_do_getcwd(dirname, current_path_length + len(dirname) + 1)\r
                    except OSError as e:\r
                        expected_errno = errno.ENAMETOOLONG\r
                        if 'sunos' in sys.platform or 'openbsd' in sys.platform:\r
                            expected_errno = errno.ERANGE # Issue 9185\r
                        self.assertEqual(e.errno, expected_errno)\r
                    finally:\r
                        os.chdir('..')\r
                        os.rmdir(dirname)\r
\r
                _create_and_do_getcwd(dirname)\r
\r
            finally:\r
                os.chdir(curdir)\r
                shutil.rmtree(base_path)\r
\r
    @unittest.skipUnless(hasattr(os, 'getegid'), "test needs os.getegid()")\r
    def test_getgroups(self):\r
        with os.popen('id -G') as idg:\r
            groups = idg.read().strip()\r
\r
        if not groups:\r
            raise unittest.SkipTest("need working 'id -G'")\r
\r
        # 'id -G' and 'os.getgroups()' should return the same\r
        # groups, ignoring order and duplicates.\r
        # #10822 - it is implementation defined whether posix.getgroups()\r
        # includes the effective gid so we include it anyway, since id -G does\r
        self.assertEqual(\r
                set([int(x) for x in groups.split()]),\r
                set(posix.getgroups() + [posix.getegid()]))\r
\r
class PosixGroupsTester(unittest.TestCase):\r
\r
    def setUp(self):\r
        if posix.getuid() != 0:\r
            raise unittest.SkipTest("not enough privileges")\r
        if not hasattr(posix, 'getgroups'):\r
            raise unittest.SkipTest("need posix.getgroups")\r
        if sys.platform == 'darwin':\r
            raise unittest.SkipTest("getgroups(2) is broken on OSX")\r
        self.saved_groups = posix.getgroups()\r
\r
    def tearDown(self):\r
        if hasattr(posix, 'setgroups'):\r
            posix.setgroups(self.saved_groups)\r
        elif hasattr(posix, 'initgroups'):\r
            name = pwd.getpwuid(posix.getuid()).pw_name\r
            posix.initgroups(name, self.saved_groups[0])\r
\r
    @unittest.skipUnless(hasattr(posix, 'initgroups'),\r
                         "test needs posix.initgroups()")\r
    def test_initgroups(self):\r
        # find missing group\r
\r
        g = max(self.saved_groups) + 1\r
        name = pwd.getpwuid(posix.getuid()).pw_name\r
        posix.initgroups(name, g)\r
        self.assertIn(g, posix.getgroups())\r
\r
    @unittest.skipUnless(hasattr(posix, 'setgroups'),\r
                         "test needs posix.setgroups()")\r
    def test_setgroups(self):\r
        for groups in [[0], range(16)]:\r
            posix.setgroups(groups)\r
            self.assertListEqual(groups, posix.getgroups())\r
\r
\r
def test_main():\r
    test_support.run_unittest(PosixTester, PosixGroupsTester)\r
\r
if __name__ == '__main__':\r
    test_main()\r