Lib.test.test_file2k.py Maven / Gradle / Ivy
import sys
import os
import errno
import unittest
import time
from array import array
from weakref import proxy
try:
import threading
except ImportError:
threading = None
from test import test_support
from test.test_support import TESTFN, run_unittest
from UserList import UserList
class AutoFileTests(unittest.TestCase):
# file tests for which a test file is automatically set up
def setUp(self):
self.f = open(TESTFN, 'wb')
def tearDown(self):
if self.f:
self.f.close()
os.remove(TESTFN)
def testWeakRefs(self):
# verify weak references
p = proxy(self.f)
p.write('teststring')
self.assertEqual(self.f.tell(), p.tell())
self.f.close()
self.f = None
if test_support.is_jython: # GC is not immediate: borrow a trick
from test_weakref import extra_collect
extra_collect()
self.assertRaises(ReferenceError, getattr, p, 'tell')
def testAttributes(self):
# verify expected attributes exist
f = self.f
with test_support.check_py3k_warnings():
softspace = f.softspace
f.name # merely shouldn't blow up
f.mode # ditto
f.closed # ditto
with test_support.check_py3k_warnings():
# verify softspace is writable
f.softspace = softspace # merely shouldn't blow up
# verify the others aren't
for attr in 'name', 'mode', 'closed':
self.assertRaises((AttributeError, TypeError), setattr, f, attr, 'oops')
def testReadinto(self):
# verify readinto
self.f.write('12')
self.f.close()
a = array('c', 'x'*10)
self.f = open(TESTFN, 'rb')
n = self.f.readinto(a)
self.assertEqual('12', a.tostring()[:n])
def testWritelinesUserList(self):
# verify writelines with instance sequence
l = UserList(['1', '2'])
self.f.writelines(l)
self.f.close()
self.f = open(TESTFN, 'rb')
buf = self.f.read()
self.assertEqual(buf, '12')
def testWritelinesIntegers(self):
# verify writelines with integers
self.assertRaises(TypeError, self.f.writelines, [1, 2, 3])
def testWritelinesIntegersUserList(self):
# verify writelines with integers in UserList
l = UserList([1,2,3])
self.assertRaises(TypeError, self.f.writelines, l)
def testWritelinesNonString(self):
# verify writelines with non-string object
class NonString:
pass
self.assertRaises(TypeError, self.f.writelines,
[NonString(), NonString()])
def testRepr(self):
# verify repr works
self.assertTrue(repr(self.f).startswith(">sys.__stdout__, (
' Skipping sys.stdin.seek(-1), it may crash the interpreter.'
' Test manually.')
self.assertRaises(IOError, sys.stdin.truncate)
def testUnicodeOpen(self):
# verify repr works for unicode too
self.f = f = open(unicode(TESTFN), "w")
self.assertTrue(repr(f).startswith("
# "file.truncate fault on windows"
self.f = f = open(TESTFN, 'wb')
f.write('12345678901') # 11 bytes
f.close()
self.f = f = open(TESTFN,'rb+')
data = f.read(5)
if data != '12345':
self.fail("Read on file opened for update failed %r" % data)
if f.tell() != 5:
self.fail("File pos after read wrong %d" % f.tell())
f.truncate()
if f.tell() != 5:
self.fail("File pos after ftruncate wrong %d" % f.tell())
f.close()
size = os.path.getsize(TESTFN)
if size != 5:
self.fail("File size after ftruncate wrong %d" % size)
try:
bug801631()
finally:
os.unlink(TESTFN)
@unittest.skipIf(test_support.is_jython, "Specific to CPython")
def testIteration(self):
# Test the complex interaction when mixing file-iteration and the
# various read* methods. Ostensibly, the mixture could just be tested
# to work when it should work according to the Python language,
# instead of fail when it should fail according to the current CPython
# implementation. People don't always program Python the way they
# should, though, and the implemenation might change in subtle ways,
# so we explicitly test for errors, too; the test will just have to
# be updated when the implementation changes.
dataoffset = 16384
filler = "ham\n"
assert not dataoffset % len(filler), \
"dataoffset must be multiple of len(filler)"
nchunks = dataoffset // len(filler)
testlines = [
"spam, spam and eggs\n",
"eggs, spam, ham and spam\n",
"saussages, spam, spam and eggs\n",
"spam, ham, spam and eggs\n",
"spam, spam, spam, spam, spam, ham, spam\n",
"wonderful spaaaaaam.\n"
]
methods = [("readline", ()), ("read", ()), ("readlines", ()),
("readinto", (array("c", " "*100),))]
try:
# Prepare the testfile
bag = open(TESTFN, "w")
bag.write(filler * nchunks)
bag.writelines(testlines)
bag.close()
# Test for appropriate errors mixing read* and iteration
for methodname, args in methods:
self.f = f = open(TESTFN)
if f.next() != filler:
self.fail, "Broken testfile"
meth = getattr(f, methodname)
try:
meth(*args)
except ValueError:
pass
else:
self.fail("%s%r after next() didn't raise ValueError" %
(methodname, args))
f.close()
# Test to see if harmless (by accident) mixing of read* and
# iteration still works. This depends on the size of the internal
# iteration buffer (currently 8192,) but we can test it in a
# flexible manner. Each line in the bag o' ham is 4 bytes
# ("h", "a", "m", "\n"), so 4096 lines of that should get us
# exactly on the buffer boundary for any power-of-2 buffersize
# between 4 and 16384 (inclusive).
self.f = f = open(TESTFN)
for i in range(nchunks):
f.next()
testline = testlines.pop(0)
try:
line = f.readline()
except ValueError:
self.fail("readline() after next() with supposedly empty "
"iteration-buffer failed anyway")
if line != testline:
self.fail("readline() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
testline = testlines.pop(0)
buf = array("c", "\x00" * len(testline))
try:
f.readinto(buf)
except ValueError:
self.fail("readinto() after next() with supposedly empty "
"iteration-buffer failed anyway")
line = buf.tostring()
if line != testline:
self.fail("readinto() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
testline = testlines.pop(0)
try:
line = f.read(len(testline))
except ValueError:
self.fail("read() after next() with supposedly empty "
"iteration-buffer failed anyway")
if line != testline:
self.fail("read() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
try:
lines = f.readlines()
except ValueError:
self.fail("readlines() after next() with supposedly empty "
"iteration-buffer failed anyway")
if lines != testlines:
self.fail("readlines() after next() with empty buffer "
"failed. Got %r, expected %r" % (line, testline))
# Reading after iteration hit EOF shouldn't hurt either
self.f = f = open(TESTFN)
try:
for line in f:
pass
try:
f.readline()
f.readinto(buf)
f.read()
f.readlines()
except ValueError:
self.fail("read* failed after next() consumed file")
finally:
f.close()
finally:
os.unlink(TESTFN)
@unittest.skipUnless(test_support.is_jython, "Applicable to Jython")
def testIterationMixes(self):
# And now for something completely different. An implementation where
# various read* methods mix happily with iteration over the lines of
# a file using next().
sheep = [
"It's my belief that these sheep\n",
"are labouring under the\n",
"mis-apprehension that they're birds.\n",
"Now witness their attempts\n",
"to fly from tree to tree.\n",
"Notice that they do not so much fly\n",
"as plummet.\n"
]
# Prepare the testfile
self.f = f = open(TESTFN, "w")
f.writelines(sheep)
f.close()
# Test for appropriate results mixing read* and iteration
self.f = f = open(TESTFN)
self.assertEqual(f.next(), sheep[0])
self.assertEqual(f.readline(), sheep[1])
self.assertEqual(f.next(), sheep[2])
self.assertEqual(f.read(5), sheep[3][:5])
r = array('c', "1234567")
f.readinto(r)
self.assertEqual(r, array('c', sheep[3][5:12]))
self.assertEqual(f.next(), sheep[3][12:])
r = f.readlines()
self.assertEqual(r, sheep[4:])
self.assertRaises(StopIteration, f.next)
f.close()
class FileSubclassTests(unittest.TestCase):
def testExit(self):
# test that exiting with context calls subclass' close
class C(file):
def __init__(self, *args):
self.subclass_closed = False
file.__init__(self, *args)
def close(self):
self.subclass_closed = True
file.close(self)
with C(TESTFN, 'w') as f:
pass
self.assertTrue(f.subclass_closed)
@unittest.skipUnless(threading, 'Threading required for this test.')
class FileThreadingTests(unittest.TestCase):
# These tests check the ability to call various methods of file objects
# (including close()) concurrently without crashing the Python interpreter.
# See #815646, #595601
# Modified for Jython so that each worker thread holds *and closes* its own
# file object, since we cannot rely on immediate garbage collection closing
# files. (Open file objects prevent deletion of TESTFN on Windows at least.)
def setUp(self):
self._threads = test_support.threading_setup()
self.filename = TESTFN
self.exc_info = None
with open(self.filename, "w") as f:
f.write("\n".join("0123456789"))
self._count_lock = threading.Lock()
self.close_count = 0
self.close_success_count = 0
self.use_buffering = False
def tearDown(self):
try:
os.remove(self.filename)
except EnvironmentError as ee:
# (Jython addition) detect failure common on Windows, on missing
# close, that creates spurious errors in subsequent tests.
if ee.errno != errno.ENOENT:
raise ee
test_support.threading_cleanup(*self._threads)
def _create_file(self):
if self.use_buffering:
return open(self.filename, "w+", buffering=1024*16)
else:
return open(self.filename, "w+")
def _close_file(self, f):
with self._count_lock:
self.close_count += 1
f.close()
with self._count_lock:
self.close_success_count += 1
# Close one file object and return a new one
def _close_and_reopen_file(self, f):
self._close_file(f)
return self._create_file()
def _run_workers(self, func, nb_workers, duration=0.2):
with self._count_lock:
self.close_count = 0
self.close_success_count = 0
self.do_continue = True
threads = []
try:
for i in range(nb_workers):
t = threading.Thread(target=func)
t.start()
threads.append(t)
for _ in xrange(100):
time.sleep(duration/100)
with self._count_lock:
if self.close_count-self.close_success_count > nb_workers+1:
if test_support.verbose:
print 'Q',
break
time.sleep(duration)
finally:
self.do_continue = False
for t in threads:
t.join()
def _test_close_open_io(self, io_func, nb_workers=5):
def worker():
# Each worker has its own currently open file object
myfile = None
try:
myfile = self._create_file()
while self.do_continue:
io_func(myfile)
myfile = self._close_and_reopen_file(myfile)
except Exception as e:
# Stop the test (other threads) and remember why
self.do_continue = False
self.exc_info = sys.exc_info()
# Finally close the last file object
if myfile:
self._close_file(myfile)
self._run_workers(worker, nb_workers)
if self.exc_info:
# Some worker saved an exception: re-raise it now
raise self.exc_info[0], self.exc_info[1], self.exc_info[2]
if test_support.verbose:
# Useful verbose statistics when tuning this test to take
# less time to run but still ensuring that its still useful.
#
# the percent of close calls that raised an error
percent = 100.
if self.close_count > 0:
percent -= 100.*self.close_success_count/self.close_count
print self.close_count, ('%.4f ' % percent),
# Each test function defines an operation on the worker's file object
def test_close_open(self):
def io_func(f):
pass
self._test_close_open_io(io_func)
def test_close_open_flush(self):
def io_func(f):
f.flush()
self._test_close_open_io(io_func)
def test_close_open_iter(self):
def io_func(f):
list(iter(f))
self._test_close_open_io(io_func)
def test_close_open_isatty(self):
def io_func(f):
f.isatty()
self._test_close_open_io(io_func)
def test_close_open_print(self):
def io_func(f):
print >> f, ''
self._test_close_open_io(io_func)
def test_close_open_print_buffered(self):
self.use_buffering = True
def io_func(f):
print >> f, ''
self._test_close_open_io(io_func)
def test_close_open_read(self):
def io_func(f):
f.read(0)
self._test_close_open_io(io_func)
def test_close_open_readinto(self):
def io_func(f):
a = array('c', 'xxxxx')
f.readinto(a)
self._test_close_open_io(io_func)
def test_close_open_readline(self):
def io_func(f):
f.readline()
self._test_close_open_io(io_func)
def test_close_open_readlines(self):
def io_func(f):
f.readlines()
self._test_close_open_io(io_func)
def test_close_open_seek(self):
def io_func(f):
f.seek(0, 0)
self._test_close_open_io(io_func)
def test_close_open_tell(self):
def io_func(f):
f.tell()
self._test_close_open_io(io_func)
def test_close_open_truncate(self):
def io_func(f):
f.truncate()
self._test_close_open_io(io_func)
def test_close_open_write(self):
def io_func(f):
f.write('')
self._test_close_open_io(io_func)
def test_close_open_writelines(self):
def io_func(f):
f.writelines('')
self._test_close_open_io(io_func)
class StdoutTests(unittest.TestCase):
def test_move_stdout_on_write(self):
# Issue 3242: sys.stdout can be replaced (and freed) during a
# print statement; prevent a segfault in this case
save_stdout = sys.stdout
class File:
def write(self, data):
if '\n' in data:
sys.stdout = save_stdout
try:
sys.stdout = File()
print "some text"
finally:
sys.stdout = save_stdout
def test_del_stdout_before_print(self):
# Issue 4597: 'print' with no argument wasn't reporting when
# sys.stdout was deleted.
save_stdout = sys.stdout
del sys.stdout
try:
print
except RuntimeError as e:
self.assertEqual(str(e), "lost sys.stdout")
else:
self.fail("Expected RuntimeError")
finally:
sys.stdout = save_stdout
def test_unicode(self):
import subprocess
def get_message(encoding, *code):
code = ';'.join(code) # jython.bat cannot cope with '\n' in arguments
env = os.environ.copy()
env['PYTHONIOENCODING'] = encoding
process = subprocess.Popen([sys.executable, "-c", code],
stdout=subprocess.PIPE, env=env)
stdout, stderr = process.communicate()
self.assertEqual(process.returncode, 0)
return stdout
def check_message(text, encoding, expected):
stdout = get_message(encoding,
"import sys",
"sys.stdout.write(%r)" % text,
"sys.stdout.flush()")
self.assertEqual(stdout, expected)
# test the encoding
check_message(u'15\u20ac', "iso-8859-15", "15\xa4")
check_message(u'15\u20ac', "utf-8", '15\xe2\x82\xac')
check_message(u'15\u20ac', "utf-16-le", '1\x005\x00\xac\x20')
# test the error handler
check_message(u'15\u20ac', "iso-8859-1:ignore", "15")
check_message(u'15\u20ac', "iso-8859-1:replace", "15?")
check_message(u'15\u20ac', "iso-8859-1:backslashreplace", "15\\u20ac")
# test the buffer API
for objtype in ('buffer', 'bytearray'):
stdout = get_message('ascii',
'import sys',
r'sys.stdout.write(%s("\xe9"))' % objtype,
'sys.stdout.flush()')
self.assertEqual(stdout, "\xe9")
def test_main():
run_unittest(
AutoFileTests,
OtherFileTests,
FileSubclassTests,
FileThreadingTests,
StdoutTests
)
if __name__ == '__main__':
test_main()
© 2015 - 2025 Weber Informatics LLC | Privacy Policy