Add some posix functions

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
@@ skipping 116 matching lines @@
             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):
-        fp = open(support.TESTFN, 'w+')
-        try:
-            # we need to have some data to truncate
+        with open(support.TESTFN, 'w') as fp:
             fp.write('test')
             fp.flush()
-            posix.truncate(support.TESTFN, 0)
-        finally:
-            fp.close()
+        posix.truncate(support.TESTFN, 0)
 
     @unittest.skipUnless(hasattr(posix, 'fexecve'), "test needs posix.fexecve()")
     @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
-    @unittest.skipUnless(hasattr(os, 'chdir'), "test needs os.chdir()")
-    @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
+    @unittest.skipUnless(hasattr(os, 'wait'), "test needs os.wait()")
     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.fexecve(fp, [sys.executable, '-c', 'pass'], os.environ)
             else:
-                os.waitpid(pid, 0)
+                self.assertEqual(os.wait(), (pid, 0))
         finally:
             os.close(fp)
 
     @unittest.skipUnless(hasattr(posix, 'gethostid'), "test needs posix.gethostid()")
     def test_gethostid(self):
         self.assertTrue(isinstance(posix.gethostid(), int))
 
-    @unittest.skipUnless(hasattr(posix, 'sethostname'), "test needs posix.sethostname()")
-    def test_sethostname(self):
-        import socket
-        oldhn = socket.gethostname()
-        try:
-            posix.sethostname('new')
-        except OSError as inst:
-            # requires root permission
-            self.assertEqual(inst.errno, 1)
+    @unittest.skipUnless(hasattr(posix, 'sethostid'), "test needs posix.sethostid()")
+    def test_sethostid(self):
+        hid = os.gethostid()
+        try:
+            posix.sethostid(2464787)
+        except OSError as e:
+            if sys.platform.startswith("freebsd"):
+                self.assertEqual(e.errno, errno.EPERM)
+            else:
+                self.assertEqual(e.errno, errno.EACCES)
         else:
             # running test as root!
-            self.assertEqual(socket.gethostname(), 'new')
-            posix.sethostname(oldhn)
+            self.assertEqual(os.gethostid(), 2464787)
+            posix.sethostid(hid)
 
     @unittest.skipUnless(hasattr(posix, 'waitid'), "test needs posix.waitid()")
-    @unittest.skipUnless(hasattr(os, 'chdir'), "test needs os.chdir()")
     @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
     def test_waitid(self):
         pid = os.fork()
         if pid == 0:
             os.chdir(os.path.split(sys.executable)[0])
             posix.execve(sys.executable, [sys.executable, '-c', 'pass'], os.environ)
         else:
             res = posix.waitid(posix.P_PID, pid, posix.WEXITED)
-            self.assertEqual(pid, res[3])
+            self.assertEqual(pid, res.si_pid)
 
     @unittest.skipUnless(hasattr(posix, 'lockf'), "test needs posix.lockf()")
     def test_lockf(self):
         fd = os.open(support.TESTFN, os.O_WRONLY | os.O_CREAT)
         try:
             os.write(fd, b'test')
             os.lseek(fd, 0, os.SEEK_SET)
             posix.lockf(fd, posix.F_LOCK, 4)
             # section is locked
             posix.lockf(fd, posix.F_ULOCK, 4)
@@ skipping 25 matching lines @@
 
     @unittest.skipUnless(hasattr(posix, 'posix_fallocate'),
         "test needs posix.posix_fallocate()")
     def test_posix_fallocate(self):
         fd = os.open(support.TESTFN, os.O_WRONLY | os.O_CREAT)
         try:
             posix.posix_fallocate(fd, 0, 10)
         except OSError as inst:
             # issue10812, ZFS doesn't appear to support posix_fallocate,
             # so skip Solaris-based since they are likely to have ZFS.
-            if inst.errno != 22 or not sys.platform.startswith("sunos"):
+            if inst.errno != errno.EINVAL or not sys.platform.startswith("sunos"):
                 raise
         finally:
             os.close(fd)
 
     @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)
@@ skipping 46 matching lines @@
             self.assertEqual(b'test1tt2t3', posix.read(fd, 10))
         finally:
             os.close(fd)
 
     @unittest.skipUnless(hasattr(posix, 'readv'), "test needs posix.readv()")
     def test_readv(self):
         fd = os.open(support.TESTFN, os.O_RDWR | os.O_CREAT)
         try:
             os.write(fd, b'test1tt2t3')
             os.lseek(fd, 0, os.SEEK_SET)
-            a = bytearray(5)
-            b = bytearray(3)
-            c = bytearray(2)
-            self.assertEqual(posix.readv(fd, (a, b, c)), 10)
-            self.assertEqual((b'test1', b'tt2', b't3'),
-                (bytes(a), bytes(b), bytes(c)))
+            buf = [bytearray(i) for i in [5, 3, 2]]
+            self.assertEqual(posix.readv(fd, buf), 10)
+            self.assertEqual([b'test1', b'tt2', b't3'], [bytes(i) for i in buf])
         finally:
             os.close(fd)
 
     def test_dup(self):
         if hasattr(posix, 'dup'):
             fp = open(support.TESTFN)
             try:
                 fd = posix.dup(fp.fileno())
                 self.assertIsInstance(fd, int)
                 os.close(fd)
@@ skipping 278 matching lines @@
         for groups in [[0], list(range(16))]:
             posix.setgroups(groups)
             self.assertListEqual(groups, posix.getgroups())
 
 
 def test_main():
     support.run_unittest(PosixTester, PosixGroupsTester)
 
 if __name__ == '__main__':
     test_main()