← Back to branch summary

~pythonregexp2.7/python/issue2636-09-01+10

« back to all changes in this revision

Viewing changes to Lib/test/test_fileio.py

  • Committer: Jeffrey C. "The TimeHorse" Jacobs
  • Date: 2008-09-22 21:39:45 UTC
  • mfrom: (39055.1.33 Regexp-2.7)
  • Revision ID: darklord@timehorse.com-20080922213945-23717m5eiqpamcyn
Merged in changes from the Single-Loop Engine branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_fileio.py
 
1
# Adapted from test_file.py by Daniel Stutzbach
 
2
#from __future__ import unicode_literals
 
3
 
 
4
import sys
 
5
import os
 
6
import unittest
 
7
from array import array
 
8
from weakref import proxy
 
9
 
 
10
from test.test_support import TESTFN, findfile, run_unittest
 
11
from UserList import UserList
 
12
 
 
13
import _fileio
 
14
 
 
15
class AutoFileTests(unittest.TestCase):
 
16
    # file tests for which a test file is automatically set up
 
17
 
 
18
    def setUp(self):
 
19
        self.f = _fileio._FileIO(TESTFN, 'w')
 
20
 
 
21
    def tearDown(self):
 
22
        if self.f:
 
23
            self.f.close()
 
24
        os.remove(TESTFN)
 
25
 
 
26
    def testWeakRefs(self):
 
27
        # verify weak references
 
28
        p = proxy(self.f)
 
29
        p.write(bytes(range(10)))
 
30
        self.assertEquals(self.f.tell(), p.tell())
 
31
        self.f.close()
 
32
        self.f = None
 
33
        self.assertRaises(ReferenceError, getattr, p, 'tell')
 
34
 
 
35
    def testSeekTell(self):
 
36
        self.f.write(bytes(bytearray(range(20))))
 
37
        self.assertEquals(self.f.tell(), 20)
 
38
        self.f.seek(0)
 
39
        self.assertEquals(self.f.tell(), 0)
 
40
        self.f.seek(10)
 
41
        self.assertEquals(self.f.tell(), 10)
 
42
        self.f.seek(5, 1)
 
43
        self.assertEquals(self.f.tell(), 15)
 
44
        self.f.seek(-5, 1)
 
45
        self.assertEquals(self.f.tell(), 10)
 
46
        self.f.seek(-5, 2)
 
47
        self.assertEquals(self.f.tell(), 15)
 
48
 
 
49
    def testAttributes(self):
 
50
        # verify expected attributes exist
 
51
        f = self.f
 
52
 
 
53
        self.assertEquals(f.mode, "w")
 
54
        self.assertEquals(f.closed, False)
 
55
 
 
56
        # verify the attributes are readonly
 
57
        for attr in 'mode', 'closed':
 
58
            self.assertRaises((AttributeError, TypeError),
 
59
                              setattr, f, attr, 'oops')
 
60
 
 
61
    def testReadinto(self):
 
62
        # verify readinto
 
63
        self.f.write(bytes(bytearray([1, 2])))
 
64
        self.f.close()
 
65
        a = array('b', b'x'*10)
 
66
        self.f = _fileio._FileIO(TESTFN, 'r')
 
67
        n = self.f.readinto(a)
 
68
        self.assertEquals(array('b', [1, 2]), a[:n])
 
69
 
 
70
    def testRepr(self):
 
71
        self.assertEquals(repr(self.f),
 
72
                          "_fileio._FileIO(%d, %s)" % (self.f.fileno(),
 
73
                                                       repr(self.f.mode)))
 
74
 
 
75
    def testErrors(self):
 
76
        f = self.f
 
77
        self.assert_(not f.isatty())
 
78
        self.assert_(not f.closed)
 
79
        #self.assertEquals(f.name, TESTFN)
 
80
        self.assertRaises(ValueError, f.read, 10) # Open for reading
 
81
        f.close()
 
82
        self.assert_(f.closed)
 
83
        f = _fileio._FileIO(TESTFN, 'r')
 
84
        self.assertRaises(TypeError, f.readinto, "")
 
85
        self.assert_(not f.closed)
 
86
        f.close()
 
87
        self.assert_(f.closed)
 
88
 
 
89
    def testMethods(self):
 
90
        methods = ['fileno', 'isatty', 'read', 'readinto',
 
91
                   'seek', 'tell', 'truncate', 'write', 'seekable',
 
92
                   'readable', 'writable']
 
93
        if sys.platform.startswith('atheos'):
 
94
            methods.remove('truncate')
 
95
 
 
96
        self.f.close()
 
97
        self.assert_(self.f.closed)
 
98
 
 
99
        for methodname in methods:
 
100
            method = getattr(self.f, methodname)
 
101
            # should raise on closed file
 
102
            self.assertRaises(ValueError, method)
 
103
 
 
104
    def testOpendir(self):
 
105
        # Issue 3703: opening a directory should fill the errno
 
106
        # Windows always returns "[Errno 13]: Permission denied
 
107
        # Unix calls dircheck() and returns "[Errno 21]: Is a directory"
 
108
        try:
 
109
            _fileio._FileIO('.', 'r')
 
110
        except IOError as e:
 
111
            self.assertNotEqual(e.errno, 0)
 
112
        else:
 
113
            self.fail("Should have raised IOError")
 
114
 
 
115
 
 
116
class OtherFileTests(unittest.TestCase):
 
117
 
 
118
    def testAbles(self):
 
119
        try:
 
120
            f = _fileio._FileIO(TESTFN, "w")
 
121
            self.assertEquals(f.readable(), False)
 
122
            self.assertEquals(f.writable(), True)
 
123
            self.assertEquals(f.seekable(), True)
 
124
            f.close()
 
125
 
 
126
            f = _fileio._FileIO(TESTFN, "r")
 
127
            self.assertEquals(f.readable(), True)
 
128
            self.assertEquals(f.writable(), False)
 
129
            self.assertEquals(f.seekable(), True)
 
130
            f.close()
 
131
 
 
132
            f = _fileio._FileIO(TESTFN, "a+")
 
133
            self.assertEquals(f.readable(), True)
 
134
            self.assertEquals(f.writable(), True)
 
135
            self.assertEquals(f.seekable(), True)
 
136
            self.assertEquals(f.isatty(), False)
 
137
            f.close()
 
138
 
 
139
            if sys.platform != "win32":
 
140
                try:
 
141
                    f = _fileio._FileIO("/dev/tty", "a")
 
142
                except EnvironmentError:
 
143
                    # When run in a cron job there just aren't any
 
144
                    # ttys, so skip the test.  This also handles other
 
145
                    # OS'es that don't support /dev/tty.
 
146
                    pass
 
147
                else:
 
148
                    f = _fileio._FileIO("/dev/tty", "a")
 
149
                    self.assertEquals(f.readable(), False)
 
150
                    self.assertEquals(f.writable(), True)
 
151
                    if sys.platform != "darwin" and \
 
152
                       not sys.platform.startswith('freebsd') and \
 
153
                       not sys.platform.startswith('sunos'):
 
154
                        # Somehow /dev/tty appears seekable on some BSDs
 
155
                        self.assertEquals(f.seekable(), False)
 
156
                    self.assertEquals(f.isatty(), True)
 
157
                    f.close()
 
158
        finally:
 
159
            os.unlink(TESTFN)
 
160
 
 
161
    def testModeStrings(self):
 
162
        # check invalid mode strings
 
163
        for mode in ("", "aU", "wU+", "rb", "rt"):
 
164
            try:
 
165
                f = _fileio._FileIO(TESTFN, mode)
 
166
            except ValueError:
 
167
                pass
 
168
            else:
 
169
                f.close()
 
170
                self.fail('%r is an invalid file mode' % mode)
 
171
 
 
172
    def testUnicodeOpen(self):
 
173
        # verify repr works for unicode too
 
174
        f = _fileio._FileIO(str(TESTFN), "w")
 
175
        f.close()
 
176
        os.unlink(TESTFN)
 
177
 
 
178
    def testBadModeArgument(self):
 
179
        # verify that we get a sensible error message for bad mode argument
 
180
        bad_mode = "qwerty"
 
181
        try:
 
182
            f = _fileio._FileIO(TESTFN, bad_mode)
 
183
        except ValueError as msg:
 
184
            if msg.args[0] != 0:
 
185
                s = str(msg)
 
186
                if s.find(TESTFN) != -1 or s.find(bad_mode) == -1:
 
187
                    self.fail("bad error message for invalid mode: %s" % s)
 
188
            # if msg.args[0] == 0, we're probably on Windows where there may be
 
189
            # no obvious way to discover why open() failed.
 
190
        else:
 
191
            f.close()
 
192
            self.fail("no error for invalid mode: %s" % bad_mode)
 
193
 
 
194
    def testTruncateOnWindows(self):
 
195
        def bug801631():
 
196
            # SF bug <http://www.python.org/sf/801631>
 
197
            # "file.truncate fault on windows"
 
198
            f = _fileio._FileIO(TESTFN, 'w')
 
199
            f.write(bytes(bytearray(range(11))))
 
200
            f.close()
 
201
 
 
202
            f = _fileio._FileIO(TESTFN,'r+')
 
203
            data = f.read(5)
 
204
            if data != bytes(bytearray(range(5))):
 
205
                self.fail("Read on file opened for update failed %r" % data)
 
206
            if f.tell() != 5:
 
207
                self.fail("File pos after read wrong %d" % f.tell())
 
208
 
 
209
            f.truncate()
 
210
            if f.tell() != 5:
 
211
                self.fail("File pos after ftruncate wrong %d" % f.tell())
 
212
 
 
213
            f.close()
 
214
            size = os.path.getsize(TESTFN)
 
215
            if size != 5:
 
216
                self.fail("File size after ftruncate wrong %d" % size)
 
217
 
 
218
        try:
 
219
            bug801631()
 
220
        finally:
 
221
            os.unlink(TESTFN)
 
222
 
 
223
    def testAppend(self):
 
224
        try:
 
225
            f = open(TESTFN, 'wb')
 
226
            f.write(b'spam')
 
227
            f.close()
 
228
            f = open(TESTFN, 'ab')
 
229
            f.write(b'eggs')
 
230
            f.close()
 
231
            f = open(TESTFN, 'rb')
 
232
            d = f.read()
 
233
            f.close()
 
234
            self.assertEqual(d, b'spameggs')
 
235
        finally:
 
236
            try:
 
237
                os.unlink(TESTFN)
 
238
            except:
 
239
                pass
 
240
 
 
241
    def testInvalidInit(self):
 
242
        self.assertRaises(TypeError, _fileio._FileIO, "1", 0, 0)
 
243
 
 
244
 
 
245
def test_main():
 
246
    # Historically, these tests have been sloppy about removing TESTFN.
 
247
    # So get rid of it no matter what.
 
248
    try:
 
249
        run_unittest(AutoFileTests, OtherFileTests)
 
250
    finally:
 
251
        if os.path.exists(TESTFN):
 
252
            os.unlink(TESTFN)
 
253
 
 
254
if __name__ == '__main__':
 
255
    test_main()