|
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, check_warnings, 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 def testWarnings(self): |
|
245 with check_warnings() as w: |
|
246 self.assertEqual(w.warnings, []) |
|
247 self.assertRaises(TypeError, _fileio._FileIO, []) |
|
248 self.assertEqual(w.warnings, []) |
|
249 self.assertRaises(ValueError, _fileio._FileIO, "/some/invalid/name", "rt") |
|
250 self.assertEqual(w.warnings, []) |
|
251 |
|
252 |
|
253 def test_main(): |
|
254 # Historically, these tests have been sloppy about removing TESTFN. |
|
255 # So get rid of it no matter what. |
|
256 try: |
|
257 run_unittest(AutoFileTests, OtherFileTests) |
|
258 finally: |
|
259 if os.path.exists(TESTFN): |
|
260 os.unlink(TESTFN) |
|
261 |
|
262 if __name__ == '__main__': |
|
263 test_main() |