Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_fileio.py

    r2 r391  
    11# Adapted from test_file.py by Daniel Stutzbach
    2 #from __future__ import unicode_literals
     2
     3from __future__ import unicode_literals
    34
    45import sys
    56import os
     7import errno
    68import unittest
    79from array import array
    810from weakref import proxy
    9 
    10 from test.test_support import (TESTFN, findfile, check_warnings, run_unittest,
    11                                make_bad_fd)
     11from functools import wraps
    1212from UserList import UserList
    13 
    14 import _fileio
     13import _testcapi
     14
     15from test.test_support import TESTFN, check_warnings, run_unittest, make_bad_fd
     16from test.test_support import py3k_bytes as bytes
     17from test.script_helper import run_python
     18
     19from _io import FileIO as _FileIO
    1520
    1621class AutoFileTests(unittest.TestCase):
    … …  
    1823
    1924    def setUp(self):
    20         self.f = _fileio._FileIO(TESTFN, 'w')
     25        self.f = _FileIO(TESTFN, 'w')
    2126
    2227    def tearDown(self):
    … …  
    2934        p = proxy(self.f)
    3035        p.write(bytes(range(10)))
    31         self.assertEquals(self.f.tell(), p.tell())
     36        self.assertEqual(self.f.tell(), p.tell())
    3237        self.f.close()
    3338        self.f = None
    … …  
    3540
    3641    def testSeekTell(self):
    37         self.f.write(bytes(bytearray(range(20))))
    38         self.assertEquals(self.f.tell(), 20)
     42        self.f.write(bytes(range(20)))
     43        self.assertEqual(self.f.tell(), 20)
    3944        self.f.seek(0)
    40         self.assertEquals(self.f.tell(), 0)
     45        self.assertEqual(self.f.tell(), 0)
    4146        self.f.seek(10)
    42         self.assertEquals(self.f.tell(), 10)
     47        self.assertEqual(self.f.tell(), 10)
    4348        self.f.seek(5, 1)
    44         self.assertEquals(self.f.tell(), 15)
     49        self.assertEqual(self.f.tell(), 15)
    4550        self.f.seek(-5, 1)
    46         self.assertEquals(self.f.tell(), 10)
     51        self.assertEqual(self.f.tell(), 10)
    4752        self.f.seek(-5, 2)
    48         self.assertEquals(self.f.tell(), 15)
     53        self.assertEqual(self.f.tell(), 15)
    4954
    5055    def testAttributes(self):
    … …  
    5257        f = self.f
    5358
    54         self.assertEquals(f.mode, "wb")
    55         self.assertEquals(f.closed, False)
     59        self.assertEqual(f.mode, "wb")
     60        self.assertEqual(f.closed, False)
    5661
    5762        # verify the attributes are readonly
    … …  
    6267    def testReadinto(self):
    6368        # verify readinto
    64         self.f.write(bytes(bytearray([1, 2])))
    65         self.f.close()
    66         a = array('b', b'x'*10)
    67         self.f = _fileio._FileIO(TESTFN, 'r')
     69        self.f.write(b"\x01\x02")
     70        self.f.close()
     71        a = array(b'b', b'x'*10)
     72        self.f = _FileIO(TESTFN, 'r')
    6873        n = self.f.readinto(a)
    69         self.assertEquals(array('b', [1, 2]), a[:n])
     74        self.assertEqual(array(b'b', [1, 2]), a[:n])
     75
     76    def testWritelinesList(self):
     77        l = [b'123', b'456']
     78        self.f.writelines(l)
     79        self.f.close()
     80        self.f = _FileIO(TESTFN, 'rb')
     81        buf = self.f.read()
     82        self.assertEqual(buf, b'123456')
     83
     84    def testWritelinesUserList(self):
     85        l = UserList([b'123', b'456'])
     86        self.f.writelines(l)
     87        self.f.close()
     88        self.f = _FileIO(TESTFN, 'rb')
     89        buf = self.f.read()
     90        self.assertEqual(buf, b'123456')
     91
     92    def testWritelinesError(self):
     93        self.assertRaises(TypeError, self.f.writelines, [1, 2, 3])
     94        self.assertRaises(TypeError, self.f.writelines, None)
     95
     96    def test_none_args(self):
     97        self.f.write(b"hi\nbye\nabc")
     98        self.f.close()
     99        self.f = _FileIO(TESTFN, 'r')
     100        self.assertEqual(self.f.read(None), b"hi\nbye\nabc")
     101        self.f.seek(0)
     102        self.assertEqual(self.f.readline(None), b"hi\n")
     103        self.assertEqual(self.f.readlines(None), [b"bye\n", b"abc"])
    70104
    71105    def testRepr(self):
    72         self.assertEquals(repr(self.f),
    73                           "_fileio._FileIO(%d, %s)" % (self.f.fileno(),
    74                                                        repr(self.f.mode)))
     106        self.assertEqual(repr(self.f), "<_io.FileIO name=%r mode='%s'>"
     107                                       % (self.f.name, self.f.mode))
     108        del self.f.name
     109        self.assertEqual(repr(self.f), "<_io.FileIO fd=%r mode='%s'>"
     110                                       % (self.f.fileno(), self.f.mode))
     111        self.f.close()
     112        self.assertEqual(repr(self.f), "<_io.FileIO [closed]>")
    75113
    76114    def testErrors(self):
    77115        f = self.f
    78         self.assert_(not f.isatty())
    79         self.assert_(not f.closed)
    80         #self.assertEquals(f.name, TESTFN)
     116        self.assertTrue(not f.isatty())
     117        self.assertTrue(not f.closed)
     118        #self.assertEqual(f.name, TESTFN)
    81119        self.assertRaises(ValueError, f.read, 10) # Open for reading
    82120        f.close()
    83         self.assert_(f.closed)
    84         f = _fileio._FileIO(TESTFN, 'r')
     121        self.assertTrue(f.closed)
     122        f = _FileIO(TESTFN, 'r')
    85123        self.assertRaises(TypeError, f.readinto, "")
    86         self.assert_(not f.closed)
     124        self.assertTrue(not f.closed)
    87125        f.close()
    88         self.assert_(f.closed)
     126        self.assertTrue(f.closed)
    89127
    90128    def testMethods(self):
    … …  
    96134
    97135        self.f.close()
    98         self.assert_(self.f.closed)
     136        self.assertTrue(self.f.closed)
    99137
    100138        for methodname in methods:
    … …  
    108146        # Unix calls dircheck() and returns "[Errno 21]: Is a directory"
    109147        try:
    110             _fileio._FileIO('.', 'r')
     148            _FileIO('.', 'r')
    111149        except IOError as e:
    112150            self.assertNotEqual(e.errno, 0)
    … …  
    115153            self.fail("Should have raised IOError")
    116154
     155    @unittest.skipIf(os.name == 'nt', "test only works on a POSIX-like system")
     156    def testOpenDirFD(self):
     157        fd = os.open('.', os.O_RDONLY)
     158        with self.assertRaises(IOError) as cm:
     159            _FileIO(fd, 'r')
     160        os.close(fd)
     161        self.assertEqual(cm.exception.errno, errno.EISDIR)
     162
     163    #A set of functions testing that we get expected behaviour if someone has
     164    #manually closed the internal file descriptor.  First, a decorator:
     165    def ClosedFD(func):
     166        @wraps(func)
     167        def wrapper(self):
     168            #forcibly close the fd before invoking the problem function
     169            f = self.f
     170            os.close(f.fileno())
     171            try:
     172                func(self, f)
     173            finally:
     174                try:
     175                    self.f.close()
     176                except IOError:
     177                    pass
     178        return wrapper
     179
     180    def ClosedFDRaises(func):
     181        @wraps(func)
     182        def wrapper(self):
     183            #forcibly close the fd before invoking the problem function
     184            f = self.f
     185            os.close(f.fileno())
     186            try:
     187                func(self, f)
     188            except IOError as e:
     189                self.assertEqual(e.errno, errno.EBADF)
     190            else:
     191                self.fail("Should have raised IOError")
     192            finally:
     193                try:
     194                    self.f.close()
     195                except IOError:
     196                    pass
     197        return wrapper
     198
     199    @ClosedFDRaises
     200    def testErrnoOnClose(self, f):
     201        f.close()
     202
     203    @ClosedFDRaises
     204    def testErrnoOnClosedWrite(self, f):
     205        f.write('a')
     206
     207    @ClosedFDRaises
     208    def testErrnoOnClosedSeek(self, f):
     209        f.seek(0)
     210
     211    @ClosedFDRaises
     212    def testErrnoOnClosedTell(self, f):
     213        f.tell()
     214
     215    @ClosedFDRaises
     216    def testErrnoOnClosedTruncate(self, f):
     217        f.truncate(0)
     218
     219    @ClosedFD
     220    def testErrnoOnClosedSeekable(self, f):
     221        f.seekable()
     222
     223    @ClosedFD
     224    def testErrnoOnClosedReadable(self, f):
     225        f.readable()
     226
     227    @ClosedFD
     228    def testErrnoOnClosedWritable(self, f):
     229        f.writable()
     230
     231    @ClosedFD
     232    def testErrnoOnClosedFileno(self, f):
     233        f.fileno()
     234
     235    @ClosedFD
     236    def testErrnoOnClosedIsatty(self, f):
     237        self.assertEqual(f.isatty(), False)
     238
     239    def ReopenForRead(self):
     240        try:
     241            self.f.close()
     242        except IOError:
     243            pass
     244        self.f = _FileIO(TESTFN, 'r')
     245        os.close(self.f.fileno())
     246        return self.f
     247
     248    @ClosedFDRaises
     249    def testErrnoOnClosedRead(self, f):
     250        f = self.ReopenForRead()
     251        f.read(1)
     252
     253    @ClosedFDRaises
     254    def testErrnoOnClosedReadall(self, f):
     255        f = self.ReopenForRead()
     256        f.readall()
     257
     258    @ClosedFDRaises
     259    def testErrnoOnClosedReadinto(self, f):
     260        f = self.ReopenForRead()
     261        a = array(b'b', b'x'*10)
     262        f.readinto(a)
    117263
    118264class OtherFileTests(unittest.TestCase):
    … …  
    120266    def testAbles(self):
    121267        try:
    122             f = _fileio._FileIO(TESTFN, "w")
    123             self.assertEquals(f.readable(), False)
    124             self.assertEquals(f.writable(), True)
    125             self.assertEquals(f.seekable(), True)
    126             f.close()
    127 
    128             f = _fileio._FileIO(TESTFN, "r")
    129             self.assertEquals(f.readable(), True)
    130             self.assertEquals(f.writable(), False)
    131             self.assertEquals(f.seekable(), True)
    132             f.close()
    133 
    134             f = _fileio._FileIO(TESTFN, "a+")
    135             self.assertEquals(f.readable(), True)
    136             self.assertEquals(f.writable(), True)
    137             self.assertEquals(f.seekable(), True)
    138             self.assertEquals(f.isatty(), False)
     268            f = _FileIO(TESTFN, "w")
     269            self.assertEqual(f.readable(), False)
     270            self.assertEqual(f.writable(), True)
     271            self.assertEqual(f.seekable(), True)
     272            f.close()
     273
     274            f = _FileIO(TESTFN, "r")
     275            self.assertEqual(f.readable(), True)
     276            self.assertEqual(f.writable(), False)
     277            self.assertEqual(f.seekable(), True)
     278            f.close()
     279
     280            f = _FileIO(TESTFN, "a+")
     281            self.assertEqual(f.readable(), True)
     282            self.assertEqual(f.writable(), True)
     283            self.assertEqual(f.seekable(), True)
     284            self.assertEqual(f.isatty(), False)
    139285            f.close()
    140286
    141287            if sys.platform != "win32":
    142288                try:
    143                     f = _fileio._FileIO("/dev/tty", "a")
     289                    f = _FileIO("/dev/tty", "a")
    144290                except EnvironmentError:
    145291                    # When run in a cron job there just aren't any
    … …  
    148294                    pass
    149295                else:
    150                     f = _fileio._FileIO("/dev/tty", "a")
    151                     self.assertEquals(f.readable(), False)
    152                     self.assertEquals(f.writable(), True)
     296                    self.assertEqual(f.readable(), False)
     297                    self.assertEqual(f.writable(), True)
    153298                    if sys.platform != "darwin" and \
    154299                       'bsd' not in sys.platform and \
    155300                       not sys.platform.startswith('sunos'):
    156301                        # Somehow /dev/tty appears seekable on some BSDs
    157                         self.assertEquals(f.seekable(), False)
    158                     self.assertEquals(f.isatty(), True)
     302                        self.assertEqual(f.seekable(), False)
     303                    self.assertEqual(f.isatty(), True)
    159304                    f.close()
    160305        finally:
    161306            os.unlink(TESTFN)
    162307
    163     def testModeStrings(self):
     308    def testInvalidModeStrings(self):
    164309        # check invalid mode strings
    165310        for mode in ("", "aU", "wU+", "rw", "rt"):
    166311            try:
    167                 f = _fileio._FileIO(TESTFN, mode)
     312                f = _FileIO(TESTFN, mode)
    168313            except ValueError:
    169314                pass
    … …  
    172317                self.fail('%r is an invalid file mode' % mode)
    173318
     319    def testModeStrings(self):
     320        # test that the mode attribute is correct for various mode strings
     321        # given as init args
     322        try:
     323            for modes in [('w', 'wb'), ('wb', 'wb'), ('wb+', 'rb+'),
     324                          ('w+b', 'rb+'), ('a', 'ab'), ('ab', 'ab'),
     325                          ('ab+', 'ab+'), ('a+b', 'ab+'), ('r', 'rb'),
     326                          ('rb', 'rb'), ('rb+', 'rb+'), ('r+b', 'rb+')]:
     327                # read modes are last so that TESTFN will exist first
     328                with _FileIO(TESTFN, modes[0]) as f:
     329                    self.assertEqual(f.mode, modes[1])
     330        finally:
     331            if os.path.exists(TESTFN):
     332                os.unlink(TESTFN)
     333
    174334    def testUnicodeOpen(self):
    175335        # verify repr works for unicode too
    176         f = _fileio._FileIO(str(TESTFN), "w")
     336        f = _FileIO(str(TESTFN), "w")
    177337        f.close()
    178338        os.unlink(TESTFN)
    179339
     340    def testBytesOpen(self):
     341        # Opening a bytes filename
     342        try:
     343            fn = TESTFN.encode("ascii")
     344        except UnicodeEncodeError:
     345            # Skip test
     346            return
     347        f = _FileIO(fn, "w")
     348        try:
     349            f.write(b"abc")
     350            f.close()
     351            with open(TESTFN, "rb") as f:
     352                self.assertEqual(f.read(), b"abc")
     353        finally:
     354            os.unlink(TESTFN)
     355
    180356    def testInvalidFd(self):
    181         self.assertRaises(ValueError, _fileio._FileIO, -10)
    182         self.assertRaises(OSError, _fileio._FileIO, make_bad_fd())
     357        self.assertRaises(ValueError, _FileIO, -10)
     358        self.assertRaises(OSError, _FileIO, make_bad_fd())
     359        if sys.platform == 'win32':
     360            import msvcrt
     361            self.assertRaises(IOError, msvcrt.get_osfhandle, make_bad_fd())
     362        # Issue 15989
     363        self.assertRaises(TypeError, _FileIO, _testcapi.INT_MAX + 1)
     364        self.assertRaises(TypeError, _FileIO, _testcapi.INT_MIN - 1)
    183365
    184366    def testBadModeArgument(self):
    … …  
    186368        bad_mode = "qwerty"
    187369        try:
    188             f = _fileio._FileIO(TESTFN, bad_mode)
     370            f = _FileIO(TESTFN, bad_mode)
    189371        except ValueError as msg:
    190372            if msg.args[0] != 0:
    191373                s = str(msg)
    192                 if s.find(TESTFN) != -1 or s.find(bad_mode) == -1:
     374                if TESTFN in s or bad_mode not in s:
    193375                    self.fail("bad error message for invalid mode: %s" % s)
    194376            # if msg.args[0] == 0, we're probably on Windows where there may be
    … …  
    199381
    200382    def testTruncate(self):
    201         f = _fileio._FileIO(TESTFN, 'w')
     383        f = _FileIO(TESTFN, 'w')
    202384        f.write(bytes(bytearray(range(10))))
    203385        self.assertEqual(f.tell(), 10)
    … …  
    208390        self.assertEqual(f.tell(), 5)
    209391        self.assertEqual(f.seek(0, os.SEEK_END), 15)
     392        f.close()
    210393
    211394    def testTruncateOnWindows(self):
    … …  
    213396            # SF bug <http://www.python.org/sf/801631>
    214397            # "file.truncate fault on windows"
    215             f = _fileio._FileIO(TESTFN, 'w')
    216             f.write(bytes(bytearray(range(11))))
    217             f.close()
    218 
    219             f = _fileio._FileIO(TESTFN,'r+')
     398            f = _FileIO(TESTFN, 'w')
     399            f.write(bytes(range(11)))
     400            f.close()
     401
     402            f = _FileIO(TESTFN,'r+')
    220403            data = f.read(5)
    221             if data != bytes(bytearray(range(5))):
     404            if data != bytes(range(5)):
    222405                self.fail("Read on file opened for update failed %r" % data)
    223406            if f.tell() != 5:
    … …  
    257440
    258441    def testInvalidInit(self):
    259         self.assertRaises(TypeError, _fileio._FileIO, "1", 0, 0)
     442        self.assertRaises(TypeError, _FileIO, "1", 0, 0)
    260443
    261444    def testWarnings(self):
    262         with check_warnings() as w:
     445        with check_warnings(quiet=True) as w:
    263446            self.assertEqual(w.warnings, [])
    264             self.assertRaises(TypeError, _fileio._FileIO, [])
     447            self.assertRaises(TypeError, _FileIO, [])
    265448            self.assertEqual(w.warnings, [])
    266             self.assertRaises(ValueError, _fileio._FileIO, "/some/invalid/name", "rt")
     449            self.assertRaises(ValueError, _FileIO, "/some/invalid/name", "rt")
    267450            self.assertEqual(w.warnings, [])
    268451
     452    def test_surrogates(self):
     453        # Issue #8438: try to open a filename containing surrogates.
     454        # It should either fail because the file doesn't exist or the filename
     455        # can't be represented using the filesystem encoding, but not because
     456        # of a LookupError for the error handler "surrogateescape".
     457        filename = u'\udc80.txt'
     458        try:
     459            with _FileIO(filename):
     460                pass
     461        except (UnicodeEncodeError, IOError):
     462            pass
     463        # Spawn a separate Python process with a different "file system
     464        # default encoding", to exercise this further.
     465        env = dict(os.environ)
     466        env[b'LC_CTYPE'] = b'C'
     467        _, out = run_python('-c', 'import _io; _io.FileIO(%r)' % filename, env=env)
     468        if ('UnicodeEncodeError' not in out and not
     469                ( ('IOError: [Errno 2] No such file or directory' in out) or
     470                  ('IOError: [Errno 22] Invalid argument' in out) ) ):
     471            self.fail('Bad output: %r' % out)
     472
     473    def testUnclosedFDOnException(self):
     474        class MyException(Exception): pass
     475        class MyFileIO(_FileIO):
     476            def __setattr__(self, name, value):
     477                if name == "name":
     478                    raise MyException("blocked setting name")
     479                return super(MyFileIO, self).__setattr__(name, value)
     480        fd = os.open(__file__, os.O_RDONLY)
     481        self.assertRaises(MyException, MyFileIO, fd)
     482        os.close(fd)  # should not raise OSError(EBADF)
    269483
    270484def test_main():
Note: See TracChangeset for help on using the changeset viewer.