/Lib/test/test_fileio.py

http://unladen-swallow.googlecode.com/ · Python · 269 lines · 205 code · 39 blank · 25 comment · 40 complexity · 1f2443832d3b35b6f746891af852217f MD5 · raw file

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