os module: use keyword-only arguments for dir_fd and nofollow to reduce function count

Lib/test/test_posix.py

 "Test posix functions"
 
 from test import support
 
 # Skip these tests if there is no posix module.
 posix = support.import_module('posix')
 
 import errno
 import sys
 import time
 import os
 import fcntl
 import platform
 import pwd
 import shutil
 import stat
-import sysconfig
 import tempfile
 import unittest
 import warnings
 
 _DUMMY_SYMLINK = os.path.join(tempfile.gettempdir(),
                               support.TESTFN + '-dummy-symlink')
 
 class PosixTester(unittest.TestCase):
 
     def setUp(self):
@@ skipping 95 matching lines @@
 
     def test_statvfs(self):
         if hasattr(posix, 'statvfs'):
             self.assertTrue(posix.statvfs(os.curdir))
 
     def test_fstatvfs(self):
         if hasattr(posix, 'fstatvfs'):
             fp = open(support.TESTFN)
             try:
                 self.assertTrue(posix.fstatvfs(fp.fileno()))
-                self.assertTrue(posix.statvfs(fd=fp.fileno()))
+                self.assertTrue(posix.statvfs(fp.fileno()))
             finally:
                 fp.close()
 
     def test_ftruncate(self):
         if hasattr(posix, 'ftruncate'):
             fp = open(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()
 
     @unittest.skipUnless(hasattr(posix, 'truncate'), "test needs posix.truncate()")
     def test_truncate(self):
         with open(support.TESTFN, 'w') as fp:
             fp.write('test')
             fp.flush()
         posix.truncate(support.TESTFN, 0)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_FEXECVE'), "test needs execve() to support the fd parameter")
+    @unittest.skipUnless(getattr(os, 'execve') in os.supports_fd, "test needs execve() to support the fd parameter")

[Georg, 2012/06/22 20:26:02]

getattr() with no third parameter will still raise AttributeError.

[larry, 2012/06/23 00:27:56]

Fixed.  Good catch!

     @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
     def test_fexecve(self):
         fp = os.open(sys.executable, os.O_RDONLY)
         try:
             pid = os.fork()
             if pid == 0:
                 os.chdir(os.path.split(sys.executable)[0])
-                posix.execve(None, [sys.executable, '-c', 'pass'], os.environ, fd=fp)
+                posix.execve(fp, [sys.executable, '-c', 'pass'], os.environ)
             else:
                 self.assertEqual(os.waitpid(pid, 0), (pid, 0))
         finally:
             os.close(fp)
 
     @unittest.skipUnless(hasattr(posix, 'waitid'), "test needs posix.waitid()")
     @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
     def test_waitid(self):
         pid = os.fork()
         if pid == 0:
@@ skipping 54 matching lines @@
 
     @unittest.skipUnless(hasattr(posix, 'posix_fadvise'),
         "test needs posix.posix_fadvise()")
     def test_posix_fadvise(self):
         fd = os.open(support.TESTFN, os.O_RDONLY)
         try:
             posix.posix_fadvise(fd, 0, 0, posix.POSIX_FADV_WILLNEED)
         finally:
             os.close(fd)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_FUTIMES'), "test needs posix futimes()")
-    def test_futimes(self):
+    @unittest.skipUnless(os.utime in os.supports_fd, "test needs fd support in os.utime")
+    def test_utime_with_fd(self):
         now = time.time()
         fd = os.open(support.TESTFN, os.O_RDONLY)
         try:
-            posix.utime(None, None, fd=fd)
-            posix.utime(None, fd=fd)
-            self.assertRaises(TypeError, posix.utime, None, (None, None), fd=fd)
-            self.assertRaises(TypeError, posix.utime, None, (now, None), fd=fd)
-            self.assertRaises(TypeError, posix.utime, None, (None, now), fd=fd)
-            posix.utime(None, (int(now), int(now)), fd=fd)
-            posix.utime(None, (now, now), fd=fd)
+            posix.utime(fd)
+            posix.utime(fd, None)
+            self.assertRaises(TypeError, posix.utime, fd, (None, None))
+            self.assertRaises(TypeError, posix.utime, fd, (now, None))
+            self.assertRaises(TypeError, posix.utime, fd, (None, now))
+            posix.utime(fd, (int(now), int(now)))
+            posix.utime(fd, (now, now))
+            self.assertRaises(ValueError, posix.utime, fd, (now, now), ns=(now, now))
+            self.assertRaises(ValueError, posix.utime, fd, (now, 0), ns=(None, None))
+            self.assertRaises(ValueError, posix.utime, fd, (None, None), ns=(now, 0))
+            posix.utime(fd, (int(now), int((now - int(now)) * 1e9)))
+            posix.utime(fd, ns=(int(now), int((now - int(now)) * 1e9)))
+
         finally:
             os.close(fd)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_LUTIMES'), "test needs posix lutimes()")
-    def test_lutimes(self):
+    @unittest.skipUnless(os.utime in os.supports_follow_symlinks, "test needs follow_symlinks support in os.utime")
+    def test_utime_nofollow_symlinks(self):
         now = time.time()
         posix.utime(support.TESTFN, None, follow_symlinks=False)
         self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None), follow_symlinks=False)
         self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, None), follow_symlinks=False)
         self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, now), follow_symlinks=False)
         posix.utime(support.TESTFN, (int(now), int(now)), follow_symlinks=False)
         posix.utime(support.TESTFN, (now, now), follow_symlinks=False)
         posix.utime(support.TESTFN, follow_symlinks=False)
-
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_FUTIMENS'), "test needs posix futimens()")
-    def test_futimens(self):
-        now = time.time()
-        fd = os.open(support.TESTFN, os.O_RDONLY)
-        try:
-            self.assertRaises(ValueError, posix.utime, None, (now, now), ns=(now, now), fd=fd)
-            self.assertRaises(ValueError, posix.utime, None, (now, 0), ns=(None, None), fd=fd)
-            self.assertRaises(ValueError, posix.utime, None, (None, None), ns=(now, 0), fd=fd)
-            posix.utime(None, (int(now), int((now - int(now)) * 1e9)), fd=fd)
-            posix.utime(None, ns=(int(now), int((now - int(now)) * 1e9)), fd=fd)
-            posix.utime(None, fd=fd)
-        finally:
-            os.close(fd)
 
     @unittest.skipUnless(hasattr(posix, 'writev'), "test needs posix.writev()")
     def test_writev(self):
         fd = os.open(support.TESTFN, os.O_RDWR | os.O_CREAT)
         try:
             os.writev(fd, (b'test1', b'tt2', b't3'))
             os.lseek(fd, 0, os.SEEK_SET)
             self.assertEqual(b'test1tt2t3', posix.read(fd, 10))
         finally:
             os.close(fd)
@@ skipping 71 matching lines @@
                              os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)
                 self.assertRaises(OSError, os.open, support.TESTFN,
                                   os.O_RDONLY|os.O_EXLOCK|os.O_NONBLOCK)
                 os.close(fd)
 
     def test_fstat(self):
         if hasattr(posix, 'fstat'):
             fp = open(support.TESTFN)
             try:
                 self.assertTrue(posix.fstat(fp.fileno()))
-                self.assertTrue(posix.stat(fd=fp.fileno()))
+                self.assertTrue(posix.stat(fp.fileno()))
             finally:
                 fp.close()
 
     def test_stat(self):
         if hasattr(posix, 'stat'):
             self.assertTrue(posix.stat(support.TESTFN))
 
     @unittest.skipUnless(hasattr(posix, 'mkfifo'), "don't have mkfifo()")
     def test_mkfifo(self):
         support.unlink(support.TESTFN)
@@ skipping 78 matching lines @@
 
     def test_listdir(self):
         if hasattr(posix, 'listdir'):
             self.assertTrue(support.TESTFN in posix.listdir(os.curdir))
 
     def test_listdir_default(self):
         # When listdir is called without argument, it's the same as listdir(os.curdir)
         if hasattr(posix, 'listdir'):
             self.assertTrue(support.TESTFN in posix.listdir())
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_FDOPENDIR'), "test needs posix. istdir() to support fd")
+    @unittest.skipUnless(os.listdir in os.supports_fd, "test needs fd support for os.listdir()")
     def test_flistdir(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         self.addCleanup(posix.close, f)
         self.assertEqual(
             sorted(posix.listdir('.')),
-            sorted(posix.listdir(fd=f))
+            sorted(posix.listdir(f))
             )
         # Check that the fd offset was reset (issue #13739)
         self.assertEqual(
             sorted(posix.listdir('.')),
-            sorted(posix.listdir(fd=f))
+            sorted(posix.listdir(f))
             )
 
     def test_access(self):
         if hasattr(posix, 'access'):
             self.assertTrue(posix.access(support.TESTFN, os.R_OK))
 
     def test_umask(self):
         if hasattr(posix, 'umask'):
             old_mask = posix.umask(0)
             self.assertIsInstance(old_mask, int)
@@ skipping 38 matching lines @@
     def test_utime(self):
         if hasattr(posix, 'utime'):
             now = time.time()
             posix.utime(support.TESTFN, None)
             self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None))
             self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, None))
             self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, now))
             posix.utime(support.TESTFN, (int(now), int(now)))
             posix.utime(support.TESTFN, (now, now))
 
     def _test_chflags_regular_file(self, chflags_func, target_file, kwargs):

[Georg, 2012/06/22 20:26:02]

Why no **kwargs?

[larry, 2012/06/23 00:27:56]

If you look below, I'm passing literal dicts in instead of using keyword
parameters.  I guess that style isn't great--I think I was in a hurry at the
time.

Anyway, changed to use **kwargs so people like you aren't surprised.

         st = os.stat(target_file)
         self.assertTrue(hasattr(st, 'st_flags'))
         chflags_func(target_file, st.st_flags | stat.UF_IMMUTABLE, **kwargs)
         try:
             new_st = os.stat(target_file)
             self.assertEqual(st.st_flags | stat.UF_IMMUTABLE, new_st.st_flags)
             try:
                 fd = open(target_file, 'w+')
             except IOError as e:
                 self.assertEqual(e.errno, errno.EPERM)
@@ skipping 109 matching lines @@
         # '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()]))
 
     # tests for the posix *at functions follow
 
-    @unittest.skipUnless(sysconfig.get_config_var("HAVE_FACCESSAT"), "test needs posix faccessat()")
-    def test_faccessat(self):
+    @unittest.skipUnless(os.access in os.supports_dir_fd, "test needs dir_fd support for os.access()")
+    def test_access_dir_fd(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             self.assertTrue(posix.access(support.TESTFN, os.R_OK, dir_fd=f))
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var("HAVE_FCHMODAT"), "test needs posix fchmodat()")
-    def test_fchmodat(self):
+    @unittest.skipUnless(os.chmod in os.supports_dir_fd, "test needs dir_fd support in os.chmod()")
+    def test_chmod_dir_fd(self):
         os.chmod(support.TESTFN, stat.S_IRUSR)
 
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.chmod(support.TESTFN, stat.S_IRUSR | stat.S_IWUSR, dir_fd=f)
 
             s = posix.stat(support.TESTFN)
             self.assertEqual(s[0] & stat.S_IRWXU, stat.S_IRUSR | stat.S_IWUSR)
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_FCHOWNAT'), "test needs posix fchownat()")
-    def test_fchownat(self):
+    @unittest.skipUnless(os.chown in os.supports_dir_fd, "test needs dir_fd support in os.chown()")
+    def test_chown_dir_fd(self):
         support.unlink(support.TESTFN)
         support.create_empty_file(support.TESTFN)
 
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.chown(support.TESTFN, os.getuid(), os.getgid(), dir_fd=f)
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var("HAS_FSTATAT"), "test needs posix fstatat()")
-    def test_fstatat(self):
+    @unittest.skipUnless(os.stat in os.supports_dir_fd, "test needs dir_fd support in os.stat()")
+    def test_stat_dir_fd(self):
         support.unlink(support.TESTFN)
         with open(support.TESTFN, 'w') as outfile:
             outfile.write("testline\n")
 
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             s1 = posix.stat(support.TESTFN)
             s2 = posix.stat(support.TESTFN, dir_fd=f)
             self.assertEqual(s1, s2)
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_FUTIMESAT'), "test needs posix futimesat()")
-    def test_futimesat(self):
+    @unittest.skipUnless(os.utime in os.supports_dir_fd, "test needs dir_fd support in os.utime()")
+    def test_utime_dir_fd(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             now = time.time()
             posix.utime(support.TESTFN, None, dir_fd=f)
             posix.utime(support.TESTFN, dir_fd=f)
+            self.assertRaises(TypeError, posix.utime, support.TESTFN, now, dir_fd=f)
             self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None), dir_fd=f)
             self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, None), dir_fd=f)
             self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, now), dir_fd=f)
+            self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, "x"), dir_fd=f)
             posix.utime(support.TESTFN, (int(now), int(now)), dir_fd=f)
             posix.utime(support.TESTFN, (now, now), dir_fd=f)
-        finally:
-            posix.close(f)
-
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_LINKAT'), "test needs posix linkat()")
-    def test_linkat(self):
+            posix.utime(support.TESTFN,
+                    (int(now), int((now - int(now)) * 1e9)), dir_fd=f)
+            posix.utime(support.TESTFN, dir_fd=f,
+                            times=(int(now), int((now - int(now)) * 1e9)))
+
+            if os.utime in os.supports_follow_symlinks:
+                posix.utime(support.TESTFN, follow_symlinks=False, dir_fd=f)
+
+        finally:
+            posix.close(f)
+
+    @unittest.skipUnless(os.link in os.supports_dir_fd, "test needs dir_fd support in os.link()")
+    def test_link_dir_fd(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.link(support.TESTFN, support.TESTFN + 'link', src_dir_fd=f, dst_dir_fd=f)
             # should have same inodes
             self.assertEqual(posix.stat(support.TESTFN)[1],
                 posix.stat(support.TESTFN + 'link')[1])
         finally:
             posix.close(f)
             support.unlink(support.TESTFN + 'link')
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_MKDIRAT'), "test needs posix mkdirat()")
-    def test_mkdirat(self):
+    @unittest.skipUnless(os.mkdir in os.supports_dir_fd, "test needs dir_fd support in os.mkdir()")
+    def test_mkdir_dir_fd(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.mkdir(support.TESTFN + 'dir', dir_fd=f)
             posix.stat(support.TESTFN + 'dir') # should not raise exception
         finally:
             posix.close(f)
             support.rmtree(support.TESTFN + 'dir')
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_MKNODAT') and hasattr(stat, 'S_IFIFO'),
-                         "don't have mknodat()/S_IFIFO")
-    def test_mknodat(self):
+    @unittest.skipUnless((os.mknod in os.supports_dir_fd) and hasattr(stat, 'S_IFIFO'),
+                         "test requires both stat.S_IFIFO and dir_fd support for os.mknod()")
+    def test_mknod_dir_fd(self):
         # Test using mknodat() to create a FIFO (the only use specified
         # by POSIX).
         support.unlink(support.TESTFN)
         mode = stat.S_IFIFO | stat.S_IRUSR | stat.S_IWUSR
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.mknod(support.TESTFN, mode, 0, dir_fd=f)
         except OSError as e:
             # Some old systems don't allow unprivileged users to use
             # mknod(), or only support creating device nodes.
             self.assertIn(e.errno, (errno.EPERM, errno.EINVAL))
         else:
             self.assertTrue(stat.S_ISFIFO(posix.stat(support.TESTFN).st_mode))
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var("HAVE_OPENAT"), "test needs posix openat()")
-    def test_openat(self):
+    @unittest.skipUnless(os.open in os.supports_dir_fd, "test needs dir_fd support in os.open()")
+    def test_open_dir_fd(self):
         support.unlink(support.TESTFN)
         with open(support.TESTFN, 'w') as outfile:
             outfile.write("testline\n")
         a = posix.open(posix.getcwd(), posix.O_RDONLY)
         b = posix.open(support.TESTFN, posix.O_RDONLY, dir_fd=a)
         try:
             res = posix.read(b, 9).decode(encoding="utf-8")
             self.assertEqual("testline\n", res)
         finally:
             posix.close(a)
             posix.close(b)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_READLINKAT'), "test needs posix readlinkat()")
-    def test_readlinkat(self):
+    @unittest.skipUnless(os.readlink in os.supports_dir_fd, "test needs dir_fd support in os.readlink()")
+    def test_readlink_dir_fd(self):
         os.symlink(support.TESTFN, support.TESTFN + 'link')
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             self.assertEqual(posix.readlink(support.TESTFN + 'link'),
                 posix.readlink(support.TESTFN + 'link', dir_fd=f))
         finally:
             support.unlink(support.TESTFN + 'link')
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var("HAVE_RENAMEAT"), "test needs posix renameat()")
-    def test_renameat(self):
+    @unittest.skipUnless(os.rename in os.supports_dir_fd, "test needs dir_fd support in os.rename()")
+    def test_rename_dir_fd(self):
         support.unlink(support.TESTFN)
         support.create_empty_file(support.TESTFN + 'ren')
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.rename(support.TESTFN + 'ren', support.TESTFN, src_dir_fd=f, dst_dir_fd=f)
         except:
             posix.rename(support.TESTFN + 'ren', support.TESTFN)
             raise
         else:
             posix.stat(support.TESTFN) # should not throw exception
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var("HAVE_SYMLINKAT"), "test needs posix symlinkat()")
-    def test_symlinkat(self):
+    @unittest.skipUnless(os.symlink in os.supports_dir_fd, "test needs dir_fd support in os.symlink()")
+    def test_symlink_dir_fd(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.symlink(support.TESTFN, support.TESTFN + 'link', dir_fd=f)
             self.assertEqual(posix.readlink(support.TESTFN + 'link'), support.TESTFN)
         finally:
             posix.close(f)
             support.unlink(support.TESTFN + 'link')
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_UNLINKAT'), "test needs posix unlinkat()")
-    def test_unlinkat(self):
+    @unittest.skipUnless(os.unlink in os.supports_dir_fd, "test needs dir_fd support in os.unlink()")
+    def test_unlink_dir_fd(self):
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         support.create_empty_file(support.TESTFN + 'del')
         posix.stat(support.TESTFN + 'del') # should not throw exception
         try:
             posix.unlink(support.TESTFN + 'del', dir_fd=f)
         except:
             support.unlink(support.TESTFN + 'del')
             raise
         else:
             self.assertRaises(OSError, posix.stat, support.TESTFN + 'link')
         finally:
             posix.close(f)
 
-    @unittest.skipUnless(sysconfig.get_config_var('HAVE_UTIMENSAT'), "test needs posix utimensat()")
-    def test_utimensat(self):
-        f = posix.open(posix.getcwd(), posix.O_RDONLY)
-        try:
-            now = time.time()
-            posix.utime(support.TESTFN, (now, now), dir_fd=f)
-            posix.utime(support.TESTFN, dir_fd=f)
-            posix.utime(support.TESTFN, follow_symlinks=False, dir_fd=f)
-            self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None), dir_fd=f)
-            self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, "x"), dir_fd=f)
-            self.assertRaises(TypeError, posix.utime, support.TESTFN, now, dir_fd=f)
-            posix.utime(support.TESTFN,
-                    (int(now), int((now - int(now)) * 1e9)), dir_fd=f)
-            posix.utime(support.TESTFN, dir_fd=f,
-                            times=(int(now), int((now - int(now)) * 1e9)))
-        finally:
-            posix.close(f)
-
-    @unittest.skipUnless(sysconfig.get_config_var("HAVE_MKFIFOAT"), "don't have posix mkfifoat()")
-    def test_mkfifoat(self):
+    @unittest.skipUnless(os.mkfifo in os.supports_dir_fd, "test needs dir_fd support in os.mkfifo()")
+    def test_mkfifo_dir_fd(self):
         support.unlink(support.TESTFN)
         f = posix.open(posix.getcwd(), posix.O_RDONLY)
         try:
             posix.mkfifo(support.TESTFN, stat.S_IRUSR | stat.S_IWUSR, dir_fd=f)
             self.assertTrue(stat.S_ISFIFO(posix.stat(support.TESTFN).st_mode))
         finally:
             posix.close(f)
 
     requires_sched_h = unittest.skipUnless(hasattr(posix, 'sched_yield'),
                                            "don't have scheduling support")
@@ skipping 193 matching lines @@
             self.assertListEqual(groups, posix.getgroups())
 
 def test_main():
     try:
         support.run_unittest(PosixTester, PosixGroupsTester)
     finally:
         support.reap_children()
 
 if __name__ == '__main__':
     test_main()