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