mirror of
https://github.com/python/cpython
synced 2024-09-06 10:03:55 +00:00
369 lines
12 KiB
Python
369 lines
12 KiB
Python
# As a test suite for the os module, this is woefully inadequate, but this
|
|
# does add tests for a few functions which have been determined to be more
|
|
# portable than they had been thought to be.
|
|
|
|
import os
|
|
import unittest
|
|
import warnings
|
|
from test import test_support
|
|
|
|
warnings.filterwarnings("ignore", "tempnam", RuntimeWarning, __name__)
|
|
warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning, __name__)
|
|
|
|
class TemporaryFileTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.files = []
|
|
os.mkdir(test_support.TESTFN)
|
|
|
|
def tearDown(self):
|
|
for name in self.files:
|
|
os.unlink(name)
|
|
os.rmdir(test_support.TESTFN)
|
|
|
|
def check_tempfile(self, name):
|
|
# make sure it doesn't already exist:
|
|
self.failIf(os.path.exists(name),
|
|
"file already exists for temporary file")
|
|
# make sure we can create the file
|
|
open(name, "w")
|
|
self.files.append(name)
|
|
|
|
def test_tempnam(self):
|
|
if not hasattr(os, "tempnam"):
|
|
return
|
|
warnings.filterwarnings("ignore", "tempnam", RuntimeWarning,
|
|
r"test_os$")
|
|
self.check_tempfile(os.tempnam())
|
|
|
|
name = os.tempnam(test_support.TESTFN)
|
|
self.check_tempfile(name)
|
|
|
|
name = os.tempnam(test_support.TESTFN, "pfx")
|
|
self.assert_(os.path.basename(name)[:3] == "pfx")
|
|
self.check_tempfile(name)
|
|
|
|
def test_tmpfile(self):
|
|
if not hasattr(os, "tmpfile"):
|
|
return
|
|
fp = os.tmpfile()
|
|
fp.write("foobar")
|
|
fp.seek(0,0)
|
|
s = fp.read()
|
|
fp.close()
|
|
self.assert_(s == "foobar")
|
|
|
|
def test_tmpnam(self):
|
|
import sys
|
|
if not hasattr(os, "tmpnam"):
|
|
return
|
|
warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning,
|
|
r"test_os$")
|
|
name = os.tmpnam()
|
|
if sys.platform in ("win32",):
|
|
# The Windows tmpnam() seems useless. From the MS docs:
|
|
#
|
|
# The character string that tmpnam creates consists of
|
|
# the path prefix, defined by the entry P_tmpdir in the
|
|
# file STDIO.H, followed by a sequence consisting of the
|
|
# digit characters '0' through '9'; the numerical value
|
|
# of this string is in the range 1 - 65,535. Changing the
|
|
# definitions of L_tmpnam or P_tmpdir in STDIO.H does not
|
|
# change the operation of tmpnam.
|
|
#
|
|
# The really bizarre part is that, at least under MSVC6,
|
|
# P_tmpdir is "\\". That is, the path returned refers to
|
|
# the root of the current drive. That's a terrible place to
|
|
# put temp files, and, depending on privileges, the user
|
|
# may not even be able to open a file in the root directory.
|
|
self.failIf(os.path.exists(name),
|
|
"file already exists for temporary file")
|
|
else:
|
|
self.check_tempfile(name)
|
|
|
|
# Test attributes on return values from os.*stat* family.
|
|
class StatAttributeTests(unittest.TestCase):
|
|
def setUp(self):
|
|
os.mkdir(test_support.TESTFN)
|
|
self.fname = os.path.join(test_support.TESTFN, "f1")
|
|
f = open(self.fname, 'wb')
|
|
f.write("ABC")
|
|
f.close()
|
|
|
|
def tearDown(self):
|
|
os.unlink(self.fname)
|
|
os.rmdir(test_support.TESTFN)
|
|
|
|
def test_stat_attributes(self):
|
|
if not hasattr(os, "stat"):
|
|
return
|
|
|
|
import stat
|
|
result = os.stat(self.fname)
|
|
|
|
# Make sure direct access works
|
|
self.assertEquals(result[stat.ST_SIZE], 3)
|
|
self.assertEquals(result.st_size, 3)
|
|
|
|
import sys
|
|
|
|
# Make sure all the attributes are there
|
|
members = dir(result)
|
|
for name in dir(stat):
|
|
if name[:3] == 'ST_':
|
|
attr = name.lower()
|
|
self.assertEquals(getattr(result, attr),
|
|
result[getattr(stat, name)])
|
|
self.assert_(attr in members)
|
|
|
|
try:
|
|
result[200]
|
|
self.fail("No exception thrown")
|
|
except IndexError:
|
|
pass
|
|
|
|
# Make sure that assignment fails
|
|
try:
|
|
result.st_mode = 1
|
|
self.fail("No exception thrown")
|
|
except TypeError:
|
|
pass
|
|
|
|
try:
|
|
result.st_rdev = 1
|
|
self.fail("No exception thrown")
|
|
except (AttributeError, TypeError):
|
|
pass
|
|
|
|
try:
|
|
result.parrot = 1
|
|
self.fail("No exception thrown")
|
|
except AttributeError:
|
|
pass
|
|
|
|
# Use the stat_result constructor with a too-short tuple.
|
|
try:
|
|
result2 = os.stat_result((10,))
|
|
self.fail("No exception thrown")
|
|
except TypeError:
|
|
pass
|
|
|
|
# Use the constructr with a too-long tuple.
|
|
try:
|
|
result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
|
|
except TypeError:
|
|
pass
|
|
|
|
|
|
def test_statvfs_attributes(self):
|
|
if not hasattr(os, "statvfs"):
|
|
return
|
|
|
|
import statvfs
|
|
try:
|
|
result = os.statvfs(self.fname)
|
|
except OSError, e:
|
|
# On AtheOS, glibc always returns ENOSYS
|
|
import errno
|
|
if e.errno == errno.ENOSYS:
|
|
return
|
|
|
|
# Make sure direct access works
|
|
self.assertEquals(result.f_bfree, result[statvfs.F_BFREE])
|
|
|
|
# Make sure all the attributes are there
|
|
members = dir(result)
|
|
for name in dir(statvfs):
|
|
if name[:2] == 'F_':
|
|
attr = name.lower()
|
|
self.assertEquals(getattr(result, attr),
|
|
result[getattr(statvfs, name)])
|
|
self.assert_(attr in members)
|
|
|
|
# Make sure that assignment really fails
|
|
try:
|
|
result.f_bfree = 1
|
|
self.fail("No exception thrown")
|
|
except TypeError:
|
|
pass
|
|
|
|
try:
|
|
result.parrot = 1
|
|
self.fail("No exception thrown")
|
|
except AttributeError:
|
|
pass
|
|
|
|
# Use the constructor with a too-short tuple.
|
|
try:
|
|
result2 = os.statvfs_result((10,))
|
|
self.fail("No exception thrown")
|
|
except TypeError:
|
|
pass
|
|
|
|
# Use the constructr with a too-long tuple.
|
|
try:
|
|
result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
|
|
except TypeError:
|
|
pass
|
|
|
|
from test import mapping_tests
|
|
|
|
class EnvironTests(mapping_tests.BasicTestMappingProtocol):
|
|
"""check that os.environ object conform to mapping protocol"""
|
|
type2test = None
|
|
def _reference(self):
|
|
return {"KEY1":"VALUE1", "KEY2":"VALUE2", "KEY3":"VALUE3"}
|
|
def _empty_mapping(self):
|
|
os.environ.clear()
|
|
return os.environ
|
|
def setUp(self):
|
|
self.__save = dict(os.environ)
|
|
os.environ.clear()
|
|
def tearDown(self):
|
|
os.environ.clear()
|
|
os.environ.update(self.__save)
|
|
|
|
class WalkTests(unittest.TestCase):
|
|
"""Tests for os.walk()."""
|
|
|
|
def test_traversal(self):
|
|
import os
|
|
from os.path import join
|
|
|
|
# Build:
|
|
# TESTFN/ a file kid and two directory kids
|
|
# tmp1
|
|
# SUB1/ a file kid and a directory kid
|
|
# tmp2
|
|
# SUB11/ no kids
|
|
# SUB2/ just a file kid
|
|
# tmp3
|
|
sub1_path = join(test_support.TESTFN, "SUB1")
|
|
sub11_path = join(sub1_path, "SUB11")
|
|
sub2_path = join(test_support.TESTFN, "SUB2")
|
|
tmp1_path = join(test_support.TESTFN, "tmp1")
|
|
tmp2_path = join(sub1_path, "tmp2")
|
|
tmp3_path = join(sub2_path, "tmp3")
|
|
|
|
# Create stuff.
|
|
os.makedirs(sub11_path)
|
|
os.makedirs(sub2_path)
|
|
for path in tmp1_path, tmp2_path, tmp3_path:
|
|
f = file(path, "w")
|
|
f.write("I'm " + path + " and proud of it. Blame test_os.\n")
|
|
f.close()
|
|
|
|
# Walk top-down.
|
|
all = list(os.walk(test_support.TESTFN))
|
|
self.assertEqual(len(all), 4)
|
|
# We can't know which order SUB1 and SUB2 will appear in.
|
|
# Not flipped: TESTFN, SUB1, SUB11, SUB2
|
|
# flipped: TESTFN, SUB2, SUB1, SUB11
|
|
flipped = all[0][1][0] != "SUB1"
|
|
all[0][1].sort()
|
|
self.assertEqual(all[0], (test_support.TESTFN, ["SUB1", "SUB2"], ["tmp1"]))
|
|
self.assertEqual(all[1 + flipped], (sub1_path, ["SUB11"], ["tmp2"]))
|
|
self.assertEqual(all[2 + flipped], (sub11_path, [], []))
|
|
self.assertEqual(all[3 - 2 * flipped], (sub2_path, [], ["tmp3"]))
|
|
|
|
# Prune the search.
|
|
all = []
|
|
for root, dirs, files in os.walk(test_support.TESTFN):
|
|
all.append((root, dirs, files))
|
|
# Don't descend into SUB1.
|
|
if 'SUB1' in dirs:
|
|
# Note that this also mutates the dirs we appended to all!
|
|
dirs.remove('SUB1')
|
|
self.assertEqual(len(all), 2)
|
|
self.assertEqual(all[0], (test_support.TESTFN, ["SUB2"], ["tmp1"]))
|
|
self.assertEqual(all[1], (sub2_path, [], ["tmp3"]))
|
|
|
|
# Walk bottom-up.
|
|
all = list(os.walk(test_support.TESTFN, topdown=False))
|
|
self.assertEqual(len(all), 4)
|
|
# We can't know which order SUB1 and SUB2 will appear in.
|
|
# Not flipped: SUB11, SUB1, SUB2, TESTFN
|
|
# flipped: SUB2, SUB11, SUB1, TESTFN
|
|
flipped = all[3][1][0] != "SUB1"
|
|
all[3][1].sort()
|
|
self.assertEqual(all[3], (test_support.TESTFN, ["SUB1", "SUB2"], ["tmp1"]))
|
|
self.assertEqual(all[flipped], (sub11_path, [], []))
|
|
self.assertEqual(all[flipped + 1], (sub1_path, ["SUB11"], ["tmp2"]))
|
|
self.assertEqual(all[2 - 2 * flipped], (sub2_path, [], ["tmp3"]))
|
|
|
|
# Tear everything down. This is a decent use for bottom-up on
|
|
# Windows, which doesn't have a recursive delete command. The
|
|
# (not so) subtlety is that rmdir will fail unless the dir's
|
|
# kids are removed first, so bottom up is essential.
|
|
for root, dirs, files in os.walk(test_support.TESTFN, topdown=False):
|
|
for name in files:
|
|
os.remove(join(root, name))
|
|
for name in dirs:
|
|
os.rmdir(join(root, name))
|
|
os.rmdir(test_support.TESTFN)
|
|
|
|
class MakedirTests (unittest.TestCase):
|
|
def setUp(self):
|
|
os.mkdir(test_support.TESTFN)
|
|
|
|
def test_makedir(self):
|
|
base = test_support.TESTFN
|
|
path = os.path.join(base, 'dir1', 'dir2', 'dir3')
|
|
os.makedirs(path) # Should work
|
|
path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4')
|
|
os.makedirs(path)
|
|
|
|
# Try paths with a '.' in them
|
|
self.failUnlessRaises(OSError, os.makedirs, os.curdir)
|
|
path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', os.curdir)
|
|
os.makedirs(path)
|
|
path = os.path.join(base, 'dir1', os.curdir, 'dir2', 'dir3', 'dir4',
|
|
'dir5', 'dir6')
|
|
os.makedirs(path)
|
|
|
|
|
|
|
|
|
|
def tearDown(self):
|
|
path = os.path.join(test_support.TESTFN, 'dir1', 'dir2', 'dir3',
|
|
'dir4', 'dir5', 'dir6')
|
|
# If the tests failed, the bottom-most directory ('../dir6')
|
|
# may not have been created, so we look for the outermost directory
|
|
# that exists.
|
|
while not os.path.exists(path) and path != test_support.TESTFN:
|
|
path = os.path.dirname(path)
|
|
|
|
os.removedirs(path)
|
|
|
|
class DevNullTests (unittest.TestCase):
|
|
def test_devnull(self):
|
|
f = file(os.devnull, 'w')
|
|
f.write('hello')
|
|
f.close()
|
|
f = file(os.devnull, 'r')
|
|
self.assertEqual(f.read(), '')
|
|
f.close()
|
|
|
|
class URandomTests (unittest.TestCase):
|
|
def test_urandom(self):
|
|
try:
|
|
self.assertEqual(len(os.urandom(1)), 1)
|
|
self.assertEqual(len(os.urandom(10)), 10)
|
|
self.assertEqual(len(os.urandom(100)), 100)
|
|
self.assertEqual(len(os.urandom(1000)), 1000)
|
|
except NotImplementedError:
|
|
pass
|
|
|
|
def test_main():
|
|
test_support.run_unittest(
|
|
TemporaryFileTests,
|
|
StatAttributeTests,
|
|
EnvironTests,
|
|
WalkTests,
|
|
MakedirTests,
|
|
DevNullTests,
|
|
URandomTests
|
|
)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|