home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_fileio.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  8.6 KB  |  264 lines
  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()
  264.