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