Lib/test/test_os.py

   1 # As a test suite for the os module, this is woefully inadequate, but this
   2 # does add tests for a few functions which have been determined to be more
   3 # portable than they had been thought to be.
   4
   5 import os
   6 import errno
   7 import unittest
   8 import warnings
   9 import sys
  10 from test import test_support
  11
  12 warnings.filterwarnings("ignore", "tempnam", RuntimeWarning, __name__)
  13 warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning, __name__)
  14
  15 # Tests creating TESTFN
  16 class FileTests(unittest.TestCase):
  17     def setUp(self):
  18         if os.path.exists(test_support.TESTFN):
  19             os.unlink(test_support.TESTFN)
  20     tearDown = setUp
  21
  22     def test_access(self):
  23         f = os.open(test_support.TESTFN, os.O_CREAT|os.O_RDWR)
  24         os.close(f)
  25         self.assertTrue(os.access(test_support.TESTFN, os.W_OK))
  26
  27     def test_closerange(self):
  28         first = os.open(test_support.TESTFN, os.O_CREAT|os.O_RDWR)
  29         # We must allocate two consecutive file descriptors, otherwise
  30         # it will mess up other file descriptors (perhaps even the three
  31         # standard ones).
  32         second = os.dup(first)
  33         try:
  34             retries = 0
  35             while second != first + 1:
  36                 os.close(first)
  37                 retries += 1
  38                 if retries > 10:
  39                     # XXX test skipped
  40                     self.skipTest("couldn't allocate two consecutive fds")
  41                 first, second = second, os.dup(second)
  42         finally:
  43             os.close(second)
  44         # close a fd that is open, and one that isn't
  45         os.closerange(first, first + 2)
  46         self.assertRaises(OSError, os.write, first, "a")
  47
  48     def test_rename(self):
  49         path = unicode(test_support.TESTFN)
  50         old = sys.getrefcount(path)
  51         self.assertRaises(TypeError, os.rename, path, 0)
  52         new = sys.getrefcount(path)
  53         self.assertEqual(old, new)
  54
  55
  56 class TemporaryFileTests(unittest.TestCase):
  57     def setUp(self):
  58         self.files = []
  59         os.mkdir(test_support.TESTFN)
  60
  61     def tearDown(self):
  62         for name in self.files:
  63             os.unlink(name)
  64         os.rmdir(test_support.TESTFN)
  65
  66     def check_tempfile(self, name):
  67         # make sure it doesn't already exist:
  68         self.assertFalse(os.path.exists(name),
  69                     "file already exists for temporary file")
  70         # make sure we can create the file
  71         open(name, "w")
  72         self.files.append(name)
  73
  74     def test_tempnam(self):
  75         if not hasattr(os, "tempnam"):
  76             return
  77         warnings.filterwarnings("ignore", "tempnam", RuntimeWarning,
  78                                 r"test_os$")
  79         self.check_tempfile(os.tempnam())
  80
  81         name = os.tempnam(test_support.TESTFN)
  82         self.check_tempfile(name)
  83
  84         name = os.tempnam(test_support.TESTFN, "pfx")
  85         self.assertTrue(os.path.basename(name)[:3] == "pfx")
  86         self.check_tempfile(name)
  87
  88     def test_tmpfile(self):
  89         if not hasattr(os, "tmpfile"):
  90             return
  91         # As with test_tmpnam() below, the Windows implementation of tmpfile()
  92         # attempts to create a file in the root directory of the current drive.
  93         # On Vista and Server 2008, this test will always fail for normal users
  94         # as writing to the root directory requires elevated privileges.  With
  95         # XP and below, the semantics of tmpfile() are the same, but the user
  96         # running the test is more likely to have administrative privileges on
  97         # their account already.  If that's the case, then os.tmpfile() should
  98         # work.  In order to make this test as useful as possible, rather than
  99         # trying to detect Windows versions or whether or not the user has the
 100         # right permissions, just try and create a file in the root directory
 101         # and see if it raises a 'Permission denied' OSError.  If it does, then
 102         # test that a subsequent call to os.tmpfile() raises the same error. If
 103         # it doesn't, assume we're on XP or below and the user running the test
 104         # has administrative privileges, and proceed with the test as normal.
 105         if sys.platform == 'win32':
 106             name = '\\python_test_os_test_tmpfile.txt'
 107             if os.path.exists(name):
 108                 os.remove(name)
 109             try:
 110                 fp = open(name, 'w')
 111             except IOError, first:
 112                 # open() failed, assert tmpfile() fails in the same way.
 113                 # Although open() raises an IOError and os.tmpfile() raises an
 114                 # OSError(), 'args' will be (13, 'Permission denied') in both
 115                 # cases.
 116                 try:
 117                     fp = os.tmpfile()
 118                 except OSError, second:
 119                     self.assertEqual(first.args, second.args)
 120                 else:
 121                     self.fail("expected os.tmpfile() to raise OSError")
 122                 return
 123             else:
 124                 # open() worked, therefore, tmpfile() should work.  Close our
 125                 # dummy file and proceed with the test as normal.
 126                 fp.close()
 127                 os.remove(name)
 128
 129         fp = os.tmpfile()
 130         fp.write("foobar")
 131         fp.seek(0,0)
 132         s = fp.read()
 133         fp.close()
 134         self.assertTrue(s == "foobar")
 135
 136     def test_tmpnam(self):
 137         import sys
 138         if not hasattr(os, "tmpnam"):
 139             return
 140         warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning,
 141                                 r"test_os$")
 142         name = os.tmpnam()
 143         if sys.platform in ("win32",):
 144             # The Windows tmpnam() seems useless.  From the MS docs:
 145             #
 146             #     The character string that tmpnam creates consists of
 147             #     the path prefix, defined by the entry P_tmpdir in the
 148             #     file STDIO.H, followed by a sequence consisting of the
 149             #     digit characters '0' through '9'; the numerical value
 150             #     of this string is in the range 1 - 65,535.  Changing the
 151             #     definitions of L_tmpnam or P_tmpdir in STDIO.H does not
 152             #     change the operation of tmpnam.
 153             #
 154             # The really bizarre part is that, at least under MSVC6,
 155             # P_tmpdir is "\\".  That is, the path returned refers to
 156             # the root of the current drive.  That's a terrible place to
 157             # put temp files, and, depending on privileges, the user
 158             # may not even be able to open a file in the root directory.
 159             self.assertFalse(os.path.exists(name),
 160                         "file already exists for temporary file")
 161         else:
 162             self.check_tempfile(name)
 163
 164 # Test attributes on return values from os.*stat* family.
 165 class StatAttributeTests(unittest.TestCase):
 166     def setUp(self):
 167         os.mkdir(test_support.TESTFN)
 168         self.fname = os.path.join(test_support.TESTFN, "f1")
 169         f = open(self.fname, 'wb')
 170         f.write("ABC")
 171         f.close()
 172
 173     def tearDown(self):
 174         os.unlink(self.fname)
 175         os.rmdir(test_support.TESTFN)
 176
 177     def test_stat_attributes(self):
 178         if not hasattr(os, "stat"):
 179             return
 180
 181         import stat
 182         result = os.stat(self.fname)
 183
 184         # Make sure direct access works
 185         self.assertEquals(result[stat.ST_SIZE], 3)
 186         self.assertEquals(result.st_size, 3)
 187
 188         import sys
 189
 190         # Make sure all the attributes are there
 191         members = dir(result)
 192         for name in dir(stat):
 193             if name[:3] == 'ST_':
 194                 attr = name.lower()
 195                 if name.endswith("TIME"):
 196                     def trunc(x): return int(x)
 197                 else:
 198                     def trunc(x): return x
 199                 self.assertEquals(trunc(getattr(result, attr)),
 200                                   result[getattr(stat, name)])
 201                 self.assertTrue(attr in members)
 202
 203         try:
 204             result[200]
 205             self.fail("No exception thrown")
 206         except IndexError:
 207             pass
 208
 209         # Make sure that assignment fails
 210         try:
 211             result.st_mode = 1
 212             self.fail("No exception thrown")
 213         except TypeError:
 214             pass
 215
 216         try:
 217             result.st_rdev = 1
 218             self.fail("No exception thrown")
 219         except (AttributeError, TypeError):
 220             pass
 221
 222         try:
 223             result.parrot = 1
 224             self.fail("No exception thrown")
 225         except AttributeError:
 226             pass
 227
 228         # Use the stat_result constructor with a too-short tuple.
 229         try:
 230             result2 = os.stat_result((10,))
 231             self.fail("No exception thrown")
 232         except TypeError:
 233             pass
 234
 235         # Use the constructr with a too-long tuple.
 236         try:
 237             result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
 238         except TypeError:
 239             pass
 240
 241
 242     def test_statvfs_attributes(self):
 243         if not hasattr(os, "statvfs"):
 244             return
 245
 246         try:
 247             result = os.statvfs(self.fname)
 248         except OSError, e:
 249             # On AtheOS, glibc always returns ENOSYS
 250             if e.errno == errno.ENOSYS:
 251                 return
 252
 253         # Make sure direct access works
 254         self.assertEquals(result.f_bfree, result[3])
 255
 256         # Make sure all the attributes are there.
 257         members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files',
 258                     'ffree', 'favail', 'flag', 'namemax')
 259         for value, member in enumerate(members):
 260             self.assertEquals(getattr(result, 'f_' + member), result[value])
 261
 262         # Make sure that assignment really fails
 263         try:
 264             result.f_bfree = 1
 265             self.fail("No exception thrown")
 266         except TypeError:
 267             pass
 268
 269         try:
 270             result.parrot = 1
 271             self.fail("No exception thrown")
 272         except AttributeError:
 273             pass
 274
 275         # Use the constructor with a too-short tuple.
 276         try:
 277             result2 = os.statvfs_result((10,))
 278             self.fail("No exception thrown")
 279         except TypeError:
 280             pass
 281
 282         # Use the constructr with a too-long tuple.
 283         try:
 284             result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
 285         except TypeError:
 286             pass
 287
 288     def test_utime_dir(self):
 289         delta = 1000000
 290         st = os.stat(test_support.TESTFN)
 291         # round to int, because some systems may support sub-second
 292         # time stamps in stat, but not in utime.
 293         os.utime(test_support.TESTFN, (st.st_atime, int(st.st_mtime-delta)))
 294         st2 = os.stat(test_support.TESTFN)
 295         self.assertEquals(st2.st_mtime, int(st.st_mtime-delta))
 296
 297     # Restrict test to Win32, since there is no guarantee other
 298     # systems support centiseconds
 299     if sys.platform == 'win32':
 300         def get_file_system(path):
 301             root = os.path.splitdrive(os.path.abspath(path))[0] + '\\'
 302             import ctypes
 303             kernel32 = ctypes.windll.kernel32
 304             buf = ctypes.create_string_buffer("", 100)
 305             if kernel32.GetVolumeInformationA(root, None, 0, None, None, None, buf, len(buf)):
 306                 return buf.value
 307
 308         if get_file_system(test_support.TESTFN) == "NTFS":
 309             def test_1565150(self):
 310                 t1 = 1159195039.25
 311                 os.utime(self.fname, (t1, t1))
 312                 self.assertEquals(os.stat(self.fname).st_mtime, t1)
 313
 314         def test_1686475(self):
 315             # Verify that an open file can be stat'ed
 316             try:
 317                 os.stat(r"c:\pagefile.sys")
 318             except WindowsError, e:
 319                 if e.errno == 2: # file does not exist; cannot run test
 320                     return
 321                 self.fail("Could not stat pagefile.sys")
 322
 323 from test import mapping_tests
 324
 325 class EnvironTests(mapping_tests.BasicTestMappingProtocol):
 326     """check that os.environ object conform to mapping protocol"""
 327     type2test = None
 328     def _reference(self):
 329         return {"KEY1":"VALUE1", "KEY2":"VALUE2", "KEY3":"VALUE3"}
 330     def _empty_mapping(self):
 331         os.environ.clear()
 332         return os.environ
 333     def setUp(self):
 334         self.__save = dict(os.environ)
 335         os.environ.clear()
 336     def tearDown(self):
 337         os.environ.clear()
 338         os.environ.update(self.__save)
 339
 340     # Bug 1110478
 341     def test_update2(self):
 342         if os.path.exists("/bin/sh"):
 343             os.environ.update(HELLO="World")
 344             value = os.popen("/bin/sh -c 'echo $HELLO'").read().strip()
 345             self.assertEquals(value, "World")
 346
 347 class WalkTests(unittest.TestCase):
 348     """Tests for os.walk()."""
 349
 350     def test_traversal(self):
 351         import os
 352         from os.path import join
 353
 354         # Build:
 355         #     TESTFN/
 356         #       TEST1/              a file kid and two directory kids
 357         #         tmp1
 358         #         SUB1/             a file kid and a directory kid
 359         #           tmp2
 360         #           SUB11/          no kids
 361         #         SUB2/             a file kid and a dirsymlink kid
 362         #           tmp3
 363         #           link/           a symlink to TESTFN.2
 364         #       TEST2/
 365         #         tmp4              a lone file
 366         walk_path = join(test_support.TESTFN, "TEST1")
 367         sub1_path = join(walk_path, "SUB1")
 368         sub11_path = join(sub1_path, "SUB11")
 369         sub2_path = join(walk_path, "SUB2")
 370         tmp1_path = join(walk_path, "tmp1")
 371         tmp2_path = join(sub1_path, "tmp2")
 372         tmp3_path = join(sub2_path, "tmp3")
 373         link_path = join(sub2_path, "link")
 374         t2_path = join(test_support.TESTFN, "TEST2")
 375         tmp4_path = join(test_support.TESTFN, "TEST2", "tmp4")
 376
 377         # Create stuff.
 378         os.makedirs(sub11_path)
 379         os.makedirs(sub2_path)
 380         os.makedirs(t2_path)
 381         for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path:
 382             f = file(path, "w")
 383             f.write("I'm " + path + " and proud of it.  Blame test_os.\n")
 384             f.close()
 385         if hasattr(os, "symlink"):
 386             os.symlink(os.path.abspath(t2_path), link_path)
 387             sub2_tree = (sub2_path, ["link"], ["tmp3"])
 388         else:
 389             sub2_tree = (sub2_path, [], ["tmp3"])
 390
 391         # Walk top-down.
 392         all = list(os.walk(walk_path))
 393         self.assertEqual(len(all), 4)
 394         # We can't know which order SUB1 and SUB2 will appear in.
 395         # Not flipped:  TESTFN, SUB1, SUB11, SUB2
 396         #     flipped:  TESTFN, SUB2, SUB1, SUB11
 397         flipped = all[0][1][0] != "SUB1"
 398         all[0][1].sort()
 399         self.assertEqual(all[0], (walk_path, ["SUB1", "SUB2"], ["tmp1"]))
 400         self.assertEqual(all[1 + flipped], (sub1_path, ["SUB11"], ["tmp2"]))
 401         self.assertEqual(all[2 + flipped], (sub11_path, [], []))
 402         self.assertEqual(all[3 - 2 * flipped], sub2_tree)
 403
 404         # Prune the search.
 405         all = []
 406         for root, dirs, files in os.walk(walk_path):
 407             all.append((root, dirs, files))
 408             # Don't descend into SUB1.
 409             if 'SUB1' in dirs:
 410                 # Note that this also mutates the dirs we appended to all!
 411                 dirs.remove('SUB1')
 412         self.assertEqual(len(all), 2)
 413         self.assertEqual(all[0], (walk_path, ["SUB2"], ["tmp1"]))
 414         self.assertEqual(all[1], sub2_tree)
 415
 416         # Walk bottom-up.
 417         all = list(os.walk(walk_path, topdown=False))
 418         self.assertEqual(len(all), 4)
 419         # We can't know which order SUB1 and SUB2 will appear in.
 420         # Not flipped:  SUB11, SUB1, SUB2, TESTFN
 421         #     flipped:  SUB2, SUB11, SUB1, TESTFN
 422         flipped = all[3][1][0] != "SUB1"
 423         all[3][1].sort()
 424         self.assertEqual(all[3], (walk_path, ["SUB1", "SUB2"], ["tmp1"]))
 425         self.assertEqual(all[flipped], (sub11_path, [], []))
 426         self.assertEqual(all[flipped + 1], (sub1_path, ["SUB11"], ["tmp2"]))
 427         self.assertEqual(all[2 - 2 * flipped], sub2_tree)
 428
 429         if hasattr(os, "symlink"):
 430             # Walk, following symlinks.
 431             for root, dirs, files in os.walk(walk_path, followlinks=True):
 432                 if root == link_path:
 433                     self.assertEqual(dirs, [])
 434                     self.assertEqual(files, ["tmp4"])
 435                     break
 436             else:
 437                 self.fail("Didn't follow symlink with followlinks=True")
 438
 439     def tearDown(self):
 440         # Tear everything down.  This is a decent use for bottom-up on
 441         # Windows, which doesn't have a recursive delete command.  The
 442         # (not so) subtlety is that rmdir will fail unless the dir's
 443         # kids are removed first, so bottom up is essential.
 444         for root, dirs, files in os.walk(test_support.TESTFN, topdown=False):
 445             for name in files:
 446                 os.remove(os.path.join(root, name))
 447             for name in dirs:
 448                 dirname = os.path.join(root, name)
 449                 if not os.path.islink(dirname):
 450                     os.rmdir(dirname)
 451                 else:
 452                     os.remove(dirname)
 453         os.rmdir(test_support.TESTFN)
 454
 455 class MakedirTests (unittest.TestCase):
 456     def setUp(self):
 457         os.mkdir(test_support.TESTFN)
 458
 459     def test_makedir(self):
 460         base = test_support.TESTFN
 461         path = os.path.join(base, 'dir1', 'dir2', 'dir3')
 462         os.makedirs(path)             # Should work
 463         path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4')
 464         os.makedirs(path)
 465
 466         # Try paths with a '.' in them
 467         self.assertRaises(OSError, os.makedirs, os.curdir)
 468         path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', os.curdir)
 469         os.makedirs(path)
 470         path = os.path.join(base, 'dir1', os.curdir, 'dir2', 'dir3', 'dir4',
 471                             'dir5', 'dir6')
 472         os.makedirs(path)
 473
 474
 475
 476
 477     def tearDown(self):
 478         path = os.path.join(test_support.TESTFN, 'dir1', 'dir2', 'dir3',
 479                             'dir4', 'dir5', 'dir6')
 480         # If the tests failed, the bottom-most directory ('../dir6')
 481         # may not have been created, so we look for the outermost directory
 482         # that exists.
 483         while not os.path.exists(path) and path != test_support.TESTFN:
 484             path = os.path.dirname(path)
 485
 486         os.removedirs(path)
 487
 488 class DevNullTests (unittest.TestCase):
 489     def test_devnull(self):
 490         f = file(os.devnull, 'w')
 491         f.write('hello')
 492         f.close()
 493         f = file(os.devnull, 'r')
 494         self.assertEqual(f.read(), '')
 495         f.close()
 496
 497 class URandomTests (unittest.TestCase):
 498     def test_urandom(self):
 499         try:
 500             self.assertEqual(len(os.urandom(1)), 1)
 501             self.assertEqual(len(os.urandom(10)), 10)
 502             self.assertEqual(len(os.urandom(100)), 100)
 503             self.assertEqual(len(os.urandom(1000)), 1000)
 504             # see http://bugs.python.org/issue3708
 505             with test_support.check_warnings():
 506                 # silence deprecation warnings about float arguments
 507                 self.assertEqual(len(os.urandom(0.9)), 0)
 508                 self.assertEqual(len(os.urandom(1.1)), 1)
 509                 self.assertEqual(len(os.urandom(2.0)), 2)
 510         except NotImplementedError:
 511             pass
 512
 513 class Win32ErrorTests(unittest.TestCase):
 514     def test_rename(self):
 515         self.assertRaises(WindowsError, os.rename, test_support.TESTFN, test_support.TESTFN+".bak")
 516
 517     def test_remove(self):
 518         self.assertRaises(WindowsError, os.remove, test_support.TESTFN)
 519
 520     def test_chdir(self):
 521         self.assertRaises(WindowsError, os.chdir, test_support.TESTFN)
 522
 523     def test_mkdir(self):
 524         f = open(test_support.TESTFN, "w")
 525         try:
 526             self.assertRaises(WindowsError, os.mkdir, test_support.TESTFN)
 527         finally:
 528             f.close()
 529             os.unlink(test_support.TESTFN)
 530
 531     def test_utime(self):
 532         self.assertRaises(WindowsError, os.utime, test_support.TESTFN, None)
 533
 534     def test_chmod(self):
 535         self.assertRaises(WindowsError, os.chmod, test_support.TESTFN, 0)
 536
 537 class TestInvalidFD(unittest.TestCase):
 538     singles = ["fchdir", "fdopen", "dup", "fdatasync", "fstat",
 539                "fstatvfs", "fsync", "tcgetpgrp", "ttyname"]
 540     #singles.append("close")
 541     #We omit close because it doesn'r raise an exception on some platforms
 542     def get_single(f):
 543         def helper(self):
 544             if  hasattr(os, f):
 545                 self.check(getattr(os, f))
 546         return helper
 547     for f in singles:
 548         locals()["test_"+f] = get_single(f)
 549
 550     def check(self, f, *args):
 551         try:
 552             f(test_support.make_bad_fd(), *args)
 553         except OSError as e:
 554             self.assertEqual(e.errno, errno.EBADF)
 555         else:
 556             self.fail("%r didn't raise a OSError with a bad file descriptor"
 557                       % f)
 558
 559     def test_isatty(self):
 560         if hasattr(os, "isatty"):
 561             self.assertEqual(os.isatty(test_support.make_bad_fd()), False)
 562
 563     def test_closerange(self):
 564         if hasattr(os, "closerange"):
 565             fd = test_support.make_bad_fd()
 566             # Make sure none of the descriptors we are about to close are
 567             # currently valid (issue 6542).
 568             for i in range(10):
 569                 try: os.fstat(fd+i)
 570                 except OSError:
 571                     pass
 572                 else:
 573                     break
 574             if i < 2:
 575                 raise unittest.SkipTest(
 576                     "Unable to acquire a range of invalid file descriptors")
 577             self.assertEqual(os.closerange(fd, fd + i-1), None)
 578
 579     def test_dup2(self):
 580         if hasattr(os, "dup2"):
 581             self.check(os.dup2, 20)
 582
 583     def test_fchmod(self):
 584         if hasattr(os, "fchmod"):
 585             self.check(os.fchmod, 0)
 586
 587     def test_fchown(self):
 588         if hasattr(os, "fchown"):
 589             self.check(os.fchown, -1, -1)
 590
 591     def test_fpathconf(self):
 592         if hasattr(os, "fpathconf"):
 593             self.check(os.fpathconf, "PC_NAME_MAX")
 594
 595     def test_ftruncate(self):
 596         if hasattr(os, "ftruncate"):
 597             self.check(os.ftruncate, 0)
 598
 599     def test_lseek(self):
 600         if hasattr(os, "lseek"):
 601             self.check(os.lseek, 0, 0)
 602
 603     def test_read(self):
 604         if hasattr(os, "read"):
 605             self.check(os.read, 1)
 606
 607     def test_tcsetpgrpt(self):
 608         if hasattr(os, "tcsetpgrp"):
 609             self.check(os.tcsetpgrp, 0)
 610
 611     def test_write(self):
 612         if hasattr(os, "write"):
 613             self.check(os.write, " ")
 614
 615 if sys.platform != 'win32':
 616     class Win32ErrorTests(unittest.TestCase):
 617         pass
 618
 619     class PosixUidGidTests(unittest.TestCase):
 620         if hasattr(os, 'setuid'):
 621             def test_setuid(self):
 622                 if os.getuid() != 0:
 623                     self.assertRaises(os.error, os.setuid, 0)
 624                 self.assertRaises(OverflowError, os.setuid, 1<<32)
 625
 626         if hasattr(os, 'setgid'):
 627             def test_setgid(self):
 628                 if os.getuid() != 0:
 629                     self.assertRaises(os.error, os.setgid, 0)
 630                 self.assertRaises(OverflowError, os.setgid, 1<<32)
 631
 632         if hasattr(os, 'seteuid'):
 633             def test_seteuid(self):
 634                 if os.getuid() != 0:
 635                     self.assertRaises(os.error, os.seteuid, 0)
 636                 self.assertRaises(OverflowError, os.seteuid, 1<<32)
 637
 638         if hasattr(os, 'setegid'):
 639             def test_setegid(self):
 640                 if os.getuid() != 0:
 641                     self.assertRaises(os.error, os.setegid, 0)
 642                 self.assertRaises(OverflowError, os.setegid, 1<<32)
 643
 644         if hasattr(os, 'setreuid'):
 645             def test_setreuid(self):
 646                 if os.getuid() != 0:
 647                     self.assertRaises(os.error, os.setreuid, 0, 0)
 648                 self.assertRaises(OverflowError, os.setreuid, 1<<32, 0)
 649                 self.assertRaises(OverflowError, os.setreuid, 0, 1<<32)
 650
 651         if hasattr(os, 'setregid'):
 652             def test_setregid(self):
 653                 if os.getuid() != 0:
 654                     self.assertRaises(os.error, os.setregid, 0, 0)
 655                 self.assertRaises(OverflowError, os.setregid, 1<<32, 0)
 656                 self.assertRaises(OverflowError, os.setregid, 0, 1<<32)
 657 else:
 658     class PosixUidGidTests(unittest.TestCase):
 659         pass
 660
 661 def test_main():
 662     test_support.run_unittest(
 663         FileTests,
 664         TemporaryFileTests,
 665         StatAttributeTests,
 666         EnvironTests,
 667         WalkTests,
 668         MakedirTests,
 669         DevNullTests,
 670         URandomTests,
 671         Win32ErrorTests,
 672         TestInvalidFD,
 673         PosixUidGidTests
 674     )
 675
 676 if __name__ == "__main__":
 677     test_main()