home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_tempfile.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  25.7 KB  |  849 lines
  1. # tempfile.py unit tests.
  2. import tempfile
  3. import os
  4. import sys
  5. import re
  6. import errno
  7. import warnings
  8.  
  9. import unittest
  10. from test import test_support
  11.  
  12. warnings.filterwarnings("ignore",
  13.                         category=RuntimeWarning,
  14.                         message="mktemp", module=__name__)
  15.  
  16. if hasattr(os, 'stat'):
  17.     import stat
  18.     has_stat = 1
  19. else:
  20.     has_stat = 0
  21.  
  22. has_textmode = (tempfile._text_openflags != tempfile._bin_openflags)
  23. has_spawnl = hasattr(os, 'spawnl')
  24.  
  25. # TEST_FILES may need to be tweaked for systems depending on the maximum
  26. # number of files that can be opened at one time (see ulimit -n)
  27. if sys.platform == 'mac':
  28.     TEST_FILES = 32
  29. elif sys.platform in ('openbsd3', 'openbsd4'):
  30.     TEST_FILES = 48
  31. else:
  32.     TEST_FILES = 100
  33.  
  34. # This is organized as one test for each chunk of code in tempfile.py,
  35. # in order of their appearance in the file.  Testing which requires
  36. # threads is not done here.
  37.  
  38. # Common functionality.
  39. class TC(unittest.TestCase):
  40.  
  41.     str_check = re.compile(r"[a-zA-Z0-9_-]{6}$")
  42.  
  43.     def failOnException(self, what, ei=None):
  44.         if ei is None:
  45.             ei = sys.exc_info()
  46.         self.fail("%s raised %s: %s" % (what, ei[0], ei[1]))
  47.  
  48.     def nameCheck(self, name, dir, pre, suf):
  49.         (ndir, nbase) = os.path.split(name)
  50.         npre  = nbase[:len(pre)]
  51.         nsuf  = nbase[len(nbase)-len(suf):]
  52.  
  53.         # check for equality of the absolute paths!
  54.         self.assertEqual(os.path.abspath(ndir), os.path.abspath(dir),
  55.                          "file '%s' not in directory '%s'" % (name, dir))
  56.         self.assertEqual(npre, pre,
  57.                          "file '%s' does not begin with '%s'" % (nbase, pre))
  58.         self.assertEqual(nsuf, suf,
  59.                          "file '%s' does not end with '%s'" % (nbase, suf))
  60.  
  61.         nbase = nbase[len(pre):len(nbase)-len(suf)]
  62.         self.assert_(self.str_check.match(nbase),
  63.                      "random string '%s' does not match /^[a-zA-Z0-9_-]{6}$/"
  64.                      % nbase)
  65.  
  66. test_classes = []
  67.  
  68. class test_exports(TC):
  69.     def test_exports(self):
  70.         # There are no surprising symbols in the tempfile module
  71.         dict = tempfile.__dict__
  72.  
  73.         expected = {
  74.             "NamedTemporaryFile" : 1,
  75.             "TemporaryFile" : 1,
  76.             "mkstemp" : 1,
  77.             "mkdtemp" : 1,
  78.             "mktemp" : 1,
  79.             "TMP_MAX" : 1,
  80.             "gettempprefix" : 1,
  81.             "gettempdir" : 1,
  82.             "tempdir" : 1,
  83.             "template" : 1,
  84.             "SpooledTemporaryFile" : 1
  85.         }
  86.  
  87.         unexp = []
  88.         for key in dict:
  89.             if key[0] != '_' and key not in expected:
  90.                 unexp.append(key)
  91.         self.failUnless(len(unexp) == 0,
  92.                         "unexpected keys: %s" % unexp)
  93.  
  94. test_classes.append(test_exports)
  95.  
  96.  
  97. class test__RandomNameSequence(TC):
  98.     """Test the internal iterator object _RandomNameSequence."""
  99.  
  100.     def setUp(self):
  101.         self.r = tempfile._RandomNameSequence()
  102.  
  103.     def test_get_six_char_str(self):
  104.         # _RandomNameSequence returns a six-character string
  105.         s = self.r.next()
  106.         self.nameCheck(s, '', '', '')
  107.  
  108.     def test_many(self):
  109.         # _RandomNameSequence returns no duplicate strings (stochastic)
  110.  
  111.         dict = {}
  112.         r = self.r
  113.         for i in xrange(TEST_FILES):
  114.             s = r.next()
  115.             self.nameCheck(s, '', '', '')
  116.             self.failIf(s in dict)
  117.             dict[s] = 1
  118.  
  119.     def test_supports_iter(self):
  120.         # _RandomNameSequence supports the iterator protocol
  121.  
  122.         i = 0
  123.         r = self.r
  124.         try:
  125.             for s in r:
  126.                 i += 1
  127.                 if i == 20:
  128.                     break
  129.         except:
  130.             failOnException("iteration")
  131.  
  132. test_classes.append(test__RandomNameSequence)
  133.  
  134.  
  135. class test__candidate_tempdir_list(TC):
  136.     """Test the internal function _candidate_tempdir_list."""
  137.  
  138.     def test_nonempty_list(self):
  139.         # _candidate_tempdir_list returns a nonempty list of strings
  140.  
  141.         cand = tempfile._candidate_tempdir_list()
  142.  
  143.         self.failIf(len(cand) == 0)
  144.         for c in cand:
  145.             self.assert_(isinstance(c, basestring),
  146.                          "%s is not a string" % c)
  147.  
  148.     def test_wanted_dirs(self):
  149.         # _candidate_tempdir_list contains the expected directories
  150.  
  151.         # Make sure the interesting environment variables are all set.
  152.         added = []
  153.         try:
  154.             for envname in 'TMPDIR', 'TEMP', 'TMP':
  155.                 dirname = os.getenv(envname)
  156.                 if not dirname:
  157.                     os.environ[envname] = os.path.abspath(envname)
  158.                     added.append(envname)
  159.  
  160.             cand = tempfile._candidate_tempdir_list()
  161.  
  162.             for envname in 'TMPDIR', 'TEMP', 'TMP':
  163.                 dirname = os.getenv(envname)
  164.                 if not dirname: raise ValueError
  165.                 self.assert_(dirname in cand)
  166.  
  167.             try:
  168.                 dirname = os.getcwd()
  169.             except (AttributeError, os.error):
  170.                 dirname = os.curdir
  171.  
  172.             self.assert_(dirname in cand)
  173.  
  174.             # Not practical to try to verify the presence of OS-specific
  175.             # paths in this list.
  176.         finally:
  177.             for p in added:
  178.                 del os.environ[p]
  179.  
  180. test_classes.append(test__candidate_tempdir_list)
  181.  
  182.  
  183. # We test _get_default_tempdir by testing gettempdir.
  184.  
  185.  
  186. class test__get_candidate_names(TC):
  187.     """Test the internal function _get_candidate_names."""
  188.  
  189.     def test_retval(self):
  190.         # _get_candidate_names returns a _RandomNameSequence object
  191.         obj = tempfile._get_candidate_names()
  192.         self.assert_(isinstance(obj, tempfile._RandomNameSequence))
  193.  
  194.     def test_same_thing(self):
  195.         # _get_candidate_names always returns the same object
  196.         a = tempfile._get_candidate_names()
  197.         b = tempfile._get_candidate_names()
  198.  
  199.         self.assert_(a is b)
  200.  
  201. test_classes.append(test__get_candidate_names)
  202.  
  203.  
  204. class test__mkstemp_inner(TC):
  205.     """Test the internal function _mkstemp_inner."""
  206.  
  207.     class mkstemped:
  208.         _bflags = tempfile._bin_openflags
  209.         _tflags = tempfile._text_openflags
  210.         _close = os.close
  211.         _unlink = os.unlink
  212.  
  213.         def __init__(self, dir, pre, suf, bin):
  214.             if bin: flags = self._bflags
  215.             else:   flags = self._tflags
  216.  
  217.             (self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags)
  218.  
  219.         def write(self, str):
  220.             os.write(self.fd, str)
  221.  
  222.         def __del__(self):
  223.             self._close(self.fd)
  224.             self._unlink(self.name)
  225.  
  226.     def do_create(self, dir=None, pre="", suf="", bin=1):
  227.         if dir is None:
  228.             dir = tempfile.gettempdir()
  229.         try:
  230.             file = self.mkstemped(dir, pre, suf, bin)
  231.         except:
  232.             self.failOnException("_mkstemp_inner")
  233.  
  234.         self.nameCheck(file.name, dir, pre, suf)
  235.         return file
  236.  
  237.     def test_basic(self):
  238.         # _mkstemp_inner can create files
  239.         self.do_create().write("blat")
  240.         self.do_create(pre="a").write("blat")
  241.         self.do_create(suf="b").write("blat")
  242.         self.do_create(pre="a", suf="b").write("blat")
  243.         self.do_create(pre="aa", suf=".txt").write("blat")
  244.  
  245.     def test_basic_many(self):
  246.         # _mkstemp_inner can create many files (stochastic)
  247.         extant = range(TEST_FILES)
  248.         for i in extant:
  249.             extant[i] = self.do_create(pre="aa")
  250.  
  251.     def test_choose_directory(self):
  252.         # _mkstemp_inner can create files in a user-selected directory
  253.         dir = tempfile.mkdtemp()
  254.         try:
  255.             self.do_create(dir=dir).write("blat")
  256.         finally:
  257.             os.rmdir(dir)
  258.  
  259.     def test_file_mode(self):
  260.         # _mkstemp_inner creates files with the proper mode
  261.         if not has_stat:
  262.             return            # ugh, can't use TestSkipped.
  263.  
  264.         file = self.do_create()
  265.         mode = stat.S_IMODE(os.stat(file.name).st_mode)
  266.         expected = 0600
  267.         if sys.platform in ('win32', 'os2emx', 'mac'):
  268.             # There's no distinction among 'user', 'group' and 'world';
  269.             # replicate the 'user' bits.
  270.             user = expected >> 6
  271.             expected = user * (1 + 8 + 64)
  272.         self.assertEqual(mode, expected)
  273.  
  274.     def test_noinherit(self):
  275.         # _mkstemp_inner file handles are not inherited by child processes
  276.         if not has_spawnl:
  277.             return            # ugh, can't use TestSkipped.
  278.  
  279.         if test_support.verbose:
  280.             v="v"
  281.         else:
  282.             v="q"
  283.  
  284.         file = self.do_create()
  285.         fd = "%d" % file.fd
  286.  
  287.         try:
  288.             me = __file__
  289.         except NameError:
  290.             me = sys.argv[0]
  291.  
  292.         # We have to exec something, so that FD_CLOEXEC will take
  293.         # effect.  The core of this test is therefore in
  294.         # tf_inherit_check.py, which see.
  295.         tester = os.path.join(os.path.dirname(os.path.abspath(me)),
  296.                               "tf_inherit_check.py")
  297.  
  298.         # On Windows a spawn* /path/ with embedded spaces shouldn't be quoted,
  299.         # but an arg with embedded spaces should be decorated with double
  300.         # quotes on each end
  301.         if sys.platform in ('win32',):
  302.             decorated = '"%s"' % sys.executable
  303.             tester = '"%s"' % tester
  304.         else:
  305.             decorated = sys.executable
  306.  
  307.         retval = os.spawnl(os.P_WAIT, sys.executable, decorated, tester, v, fd)
  308.         self.failIf(retval < 0,
  309.                     "child process caught fatal signal %d" % -retval)
  310.         self.failIf(retval > 0, "child process reports failure %d"%retval)
  311.  
  312.     def test_textmode(self):
  313.         # _mkstemp_inner can create files in text mode
  314.         if not has_textmode:
  315.             return            # ugh, can't use TestSkipped.
  316.  
  317.         self.do_create(bin=0).write("blat\n")
  318.         # XXX should test that the file really is a text file
  319.  
  320. test_classes.append(test__mkstemp_inner)
  321.  
  322.  
  323. class test_gettempprefix(TC):
  324.     """Test gettempprefix()."""
  325.  
  326.     def test_sane_template(self):
  327.         # gettempprefix returns a nonempty prefix string
  328.         p = tempfile.gettempprefix()
  329.  
  330.         self.assert_(isinstance(p, basestring))
  331.         self.assert_(len(p) > 0)
  332.  
  333.     def test_usable_template(self):
  334.         # gettempprefix returns a usable prefix string
  335.  
  336.         # Create a temp directory, avoiding use of the prefix.
  337.         # Then attempt to create a file whose name is
  338.         # prefix + 'xxxxxx.xxx' in that directory.
  339.         p = tempfile.gettempprefix() + "xxxxxx.xxx"
  340.         d = tempfile.mkdtemp(prefix="")
  341.         try:
  342.             p = os.path.join(d, p)
  343.             try:
  344.                 fd = os.open(p, os.O_RDWR | os.O_CREAT)
  345.             except:
  346.                 self.failOnException("os.open")
  347.             os.close(fd)
  348.             os.unlink(p)
  349.         finally:
  350.             os.rmdir(d)
  351.  
  352. test_classes.append(test_gettempprefix)
  353.  
  354.  
  355. class test_gettempdir(TC):
  356.     """Test gettempdir()."""
  357.  
  358.     def test_directory_exists(self):
  359.         # gettempdir returns a directory which exists
  360.  
  361.         dir = tempfile.gettempdir()
  362.         self.assert_(os.path.isabs(dir) or dir == os.curdir,
  363.                      "%s is not an absolute path" % dir)
  364.         self.assert_(os.path.isdir(dir),
  365.                      "%s is not a directory" % dir)
  366.  
  367.     def test_directory_writable(self):
  368.         # gettempdir returns a directory writable by the user
  369.  
  370.         # sneaky: just instantiate a NamedTemporaryFile, which
  371.         # defaults to writing into the directory returned by
  372.         # gettempdir.
  373.         try:
  374.             file = tempfile.NamedTemporaryFile()
  375.             file.write("blat")
  376.             file.close()
  377.         except:
  378.             self.failOnException("create file in %s" % tempfile.gettempdir())
  379.  
  380.     def test_same_thing(self):
  381.         # gettempdir always returns the same object
  382.         a = tempfile.gettempdir()
  383.         b = tempfile.gettempdir()
  384.  
  385.         self.assert_(a is b)
  386.  
  387. test_classes.append(test_gettempdir)
  388.  
  389.  
  390. class test_mkstemp(TC):
  391.     """Test mkstemp()."""
  392.  
  393.     def do_create(self, dir=None, pre="", suf=""):
  394.         if dir is None:
  395.             dir = tempfile.gettempdir()
  396.         try:
  397.             (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)
  398.             (ndir, nbase) = os.path.split(name)
  399.             adir = os.path.abspath(dir)
  400.             self.assertEqual(adir, ndir,
  401.                 "Directory '%s' incorrectly returned as '%s'" % (adir, ndir))
  402.         except:
  403.             self.failOnException("mkstemp")
  404.  
  405.         try:
  406.             self.nameCheck(name, dir, pre, suf)
  407.         finally:
  408.             os.close(fd)
  409.             os.unlink(name)
  410.  
  411.     def test_basic(self):
  412.         # mkstemp can create files
  413.         self.do_create()
  414.         self.do_create(pre="a")
  415.         self.do_create(suf="b")
  416.         self.do_create(pre="a", suf="b")
  417.         self.do_create(pre="aa", suf=".txt")
  418.         self.do_create(dir=".")
  419.  
  420.     def test_choose_directory(self):
  421.         # mkstemp can create directories in a user-selected directory
  422.         dir = tempfile.mkdtemp()
  423.         try:
  424.             self.do_create(dir=dir)
  425.         finally:
  426.             os.rmdir(dir)
  427.  
  428. test_classes.append(test_mkstemp)
  429.  
  430.  
  431. class test_mkdtemp(TC):
  432.     """Test mkdtemp()."""
  433.  
  434.     def do_create(self, dir=None, pre="", suf=""):
  435.         if dir is None:
  436.             dir = tempfile.gettempdir()
  437.         try:
  438.             name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)
  439.         except:
  440.             self.failOnException("mkdtemp")
  441.  
  442.         try:
  443.             self.nameCheck(name, dir, pre, suf)
  444.             return name
  445.         except:
  446.             os.rmdir(name)
  447.             raise
  448.  
  449.     def test_basic(self):
  450.         # mkdtemp can create directories
  451.         os.rmdir(self.do_create())
  452.         os.rmdir(self.do_create(pre="a"))
  453.         os.rmdir(self.do_create(suf="b"))
  454.         os.rmdir(self.do_create(pre="a", suf="b"))
  455.         os.rmdir(self.do_create(pre="aa", suf=".txt"))
  456.  
  457.     def test_basic_many(self):
  458.         # mkdtemp can create many directories (stochastic)
  459.         extant = range(TEST_FILES)
  460.         try:
  461.             for i in extant:
  462.                 extant[i] = self.do_create(pre="aa")
  463.         finally:
  464.             for i in extant:
  465.                 if(isinstance(i, basestring)):
  466.                     os.rmdir(i)
  467.  
  468.     def test_choose_directory(self):
  469.         # mkdtemp can create directories in a user-selected directory
  470.         dir = tempfile.mkdtemp()
  471.         try:
  472.             os.rmdir(self.do_create(dir=dir))
  473.         finally:
  474.             os.rmdir(dir)
  475.  
  476.     def test_mode(self):
  477.         # mkdtemp creates directories with the proper mode
  478.         if not has_stat:
  479.             return            # ugh, can't use TestSkipped.
  480.  
  481.         dir = self.do_create()
  482.         try:
  483.             mode = stat.S_IMODE(os.stat(dir).st_mode)
  484.             mode &= 0777 # Mask off sticky bits inherited from /tmp
  485.             expected = 0700
  486.             if sys.platform in ('win32', 'os2emx', 'mac'):
  487.                 # There's no distinction among 'user', 'group' and 'world';
  488.                 # replicate the 'user' bits.
  489.                 user = expected >> 6
  490.                 expected = user * (1 + 8 + 64)
  491.             self.assertEqual(mode, expected)
  492.         finally:
  493.             os.rmdir(dir)
  494.  
  495. test_classes.append(test_mkdtemp)
  496.  
  497.  
  498. class test_mktemp(TC):
  499.     """Test mktemp()."""
  500.  
  501.     # For safety, all use of mktemp must occur in a private directory.
  502.     # We must also suppress the RuntimeWarning it generates.
  503.     def setUp(self):
  504.         self.dir = tempfile.mkdtemp()
  505.  
  506.     def tearDown(self):
  507.         if self.dir:
  508.             os.rmdir(self.dir)
  509.             self.dir = None
  510.  
  511.     class mktemped:
  512.         _unlink = os.unlink
  513.         _bflags = tempfile._bin_openflags
  514.  
  515.         def __init__(self, dir, pre, suf):
  516.             self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)
  517.             # Create the file.  This will raise an exception if it's
  518.             # mysteriously appeared in the meanwhile.
  519.             os.close(os.open(self.name, self._bflags, 0600))
  520.  
  521.         def __del__(self):
  522.             self._unlink(self.name)
  523.  
  524.     def do_create(self, pre="", suf=""):
  525.         try:
  526.             file = self.mktemped(self.dir, pre, suf)
  527.         except:
  528.             self.failOnException("mktemp")
  529.  
  530.         self.nameCheck(file.name, self.dir, pre, suf)
  531.         return file
  532.  
  533.     def test_basic(self):
  534.         # mktemp can choose usable file names
  535.         self.do_create()
  536.         self.do_create(pre="a")
  537.         self.do_create(suf="b")
  538.         self.do_create(pre="a", suf="b")
  539.         self.do_create(pre="aa", suf=".txt")
  540.  
  541.     def test_many(self):
  542.         # mktemp can choose many usable file names (stochastic)
  543.         extant = range(TEST_FILES)
  544.         for i in extant:
  545.             extant[i] = self.do_create(pre="aa")
  546.  
  547. ##     def test_warning(self):
  548. ##         # mktemp issues a warning when used
  549. ##         warnings.filterwarnings("error",
  550. ##                                 category=RuntimeWarning,
  551. ##                                 message="mktemp")
  552. ##         self.assertRaises(RuntimeWarning,
  553. ##                           tempfile.mktemp, dir=self.dir)
  554.  
  555. test_classes.append(test_mktemp)
  556.  
  557.  
  558. # We test _TemporaryFileWrapper by testing NamedTemporaryFile.
  559.  
  560.  
  561. class test_NamedTemporaryFile(TC):
  562.     """Test NamedTemporaryFile()."""
  563.  
  564.     def do_create(self, dir=None, pre="", suf="", delete=True):
  565.         if dir is None:
  566.             dir = tempfile.gettempdir()
  567.         try:
  568.             file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf,
  569.                                                delete=delete)
  570.         except:
  571.             self.failOnException("NamedTemporaryFile")
  572.  
  573.         self.nameCheck(file.name, dir, pre, suf)
  574.         return file
  575.  
  576.  
  577.     def test_basic(self):
  578.         # NamedTemporaryFile can create files
  579.         self.do_create()
  580.         self.do_create(pre="a")
  581.         self.do_create(suf="b")
  582.         self.do_create(pre="a", suf="b")
  583.         self.do_create(pre="aa", suf=".txt")
  584.  
  585.     def test_creates_named(self):
  586.         # NamedTemporaryFile creates files with names
  587.         f = tempfile.NamedTemporaryFile()
  588.         self.failUnless(os.path.exists(f.name),
  589.                         "NamedTemporaryFile %s does not exist" % f.name)
  590.  
  591.     def test_del_on_close(self):
  592.         # A NamedTemporaryFile is deleted when closed
  593.         dir = tempfile.mkdtemp()
  594.         try:
  595.             f = tempfile.NamedTemporaryFile(dir=dir)
  596.             f.write('blat')
  597.             f.close()
  598.             self.failIf(os.path.exists(f.name),
  599.                         "NamedTemporaryFile %s exists after close" % f.name)
  600.         finally:
  601.             os.rmdir(dir)
  602.  
  603.     def test_dis_del_on_close(self):
  604.         # Tests that delete-on-close can be disabled
  605.         dir = tempfile.mkdtemp()
  606.         tmp = None
  607.         try:
  608.             f = tempfile.NamedTemporaryFile(dir=dir, delete=False)
  609.             tmp = f.name
  610.             f.write('blat')
  611.             f.close()
  612.             self.failUnless(os.path.exists(f.name),
  613.                         "NamedTemporaryFile %s missing after close" % f.name)
  614.         finally:
  615.             if tmp is not None:
  616.                 os.unlink(tmp)
  617.             os.rmdir(dir)
  618.  
  619.     def test_multiple_close(self):
  620.         # A NamedTemporaryFile can be closed many times without error
  621.         f = tempfile.NamedTemporaryFile()
  622.         f.write('abc\n')
  623.         f.close()
  624.         try:
  625.             f.close()
  626.             f.close()
  627.         except:
  628.             self.failOnException("close")
  629.  
  630.     def test_context_manager(self):
  631.         # A NamedTemporaryFile can be used as a context manager
  632.         with tempfile.NamedTemporaryFile() as f:
  633.             self.failUnless(os.path.exists(f.name))
  634.         self.failIf(os.path.exists(f.name))
  635.         def use_closed():
  636.             with f:
  637.                 pass
  638.         self.failUnlessRaises(ValueError, use_closed)
  639.  
  640.     # How to test the mode and bufsize parameters?
  641.  
  642. test_classes.append(test_NamedTemporaryFile)
  643.  
  644. class test_SpooledTemporaryFile(TC):
  645.     """Test SpooledTemporaryFile()."""
  646.  
  647.     def do_create(self, max_size=0, dir=None, pre="", suf=""):
  648.         if dir is None:
  649.             dir = tempfile.gettempdir()
  650.         try:
  651.             file = tempfile.SpooledTemporaryFile(max_size=max_size, dir=dir, prefix=pre, suffix=suf)
  652.         except:
  653.             self.failOnException("SpooledTemporaryFile")
  654.  
  655.         return file
  656.  
  657.  
  658.     def test_basic(self):
  659.         # SpooledTemporaryFile can create files
  660.         f = self.do_create()
  661.         self.failIf(f._rolled)
  662.         f = self.do_create(max_size=100, pre="a", suf=".txt")
  663.         self.failIf(f._rolled)
  664.  
  665.     def test_del_on_close(self):
  666.         # A SpooledTemporaryFile is deleted when closed
  667.         dir = tempfile.mkdtemp()
  668.         try:
  669.             f = tempfile.SpooledTemporaryFile(max_size=10, dir=dir)
  670.             self.failIf(f._rolled)
  671.             f.write('blat ' * 5)
  672.             self.failUnless(f._rolled)
  673.             filename = f.name
  674.             f.close()
  675.             self.failIf(os.path.exists(filename),
  676.                         "SpooledTemporaryFile %s exists after close" % filename)
  677.         finally:
  678.             os.rmdir(dir)
  679.  
  680.     def test_rewrite_small(self):
  681.         # A SpooledTemporaryFile can be written to multiple within the max_size
  682.         f = self.do_create(max_size=30)
  683.         self.failIf(f._rolled)
  684.         for i in range(5):
  685.             f.seek(0, 0)
  686.             f.write('x' * 20)
  687.         self.failIf(f._rolled)
  688.  
  689.     def test_write_sequential(self):
  690.         # A SpooledTemporaryFile should hold exactly max_size bytes, and roll
  691.         # over afterward
  692.         f = self.do_create(max_size=30)
  693.         self.failIf(f._rolled)
  694.         f.write('x' * 20)
  695.         self.failIf(f._rolled)
  696.         f.write('x' * 10)
  697.         self.failIf(f._rolled)
  698.         f.write('x')
  699.         self.failUnless(f._rolled)
  700.  
  701.     def test_sparse(self):
  702.         # A SpooledTemporaryFile that is written late in the file will extend
  703.         # when that occurs
  704.         f = self.do_create(max_size=30)
  705.         self.failIf(f._rolled)
  706.         f.seek(100, 0)
  707.         self.failIf(f._rolled)
  708.         f.write('x')
  709.         self.failUnless(f._rolled)
  710.  
  711.     def test_fileno(self):
  712.         # A SpooledTemporaryFile should roll over to a real file on fileno()
  713.         f = self.do_create(max_size=30)
  714.         self.failIf(f._rolled)
  715.         self.failUnless(f.fileno() > 0)
  716.         self.failUnless(f._rolled)
  717.  
  718.     def test_multiple_close_before_rollover(self):
  719.         # A SpooledTemporaryFile can be closed many times without error
  720.         f = tempfile.SpooledTemporaryFile()
  721.         f.write('abc\n')
  722.         self.failIf(f._rolled)
  723.         f.close()
  724.         try:
  725.             f.close()
  726.             f.close()
  727.         except:
  728.             self.failOnException("close")
  729.  
  730.     def test_multiple_close_after_rollover(self):
  731.         # A SpooledTemporaryFile can be closed many times without error
  732.         f = tempfile.SpooledTemporaryFile(max_size=1)
  733.         f.write('abc\n')
  734.         self.failUnless(f._rolled)
  735.         f.close()
  736.         try:
  737.             f.close()
  738.             f.close()
  739.         except:
  740.             self.failOnException("close")
  741.  
  742.     def test_bound_methods(self):
  743.         # It should be OK to steal a bound method from a SpooledTemporaryFile
  744.         # and use it independently; when the file rolls over, those bound
  745.         # methods should continue to function
  746.         f = self.do_create(max_size=30)
  747.         read = f.read
  748.         write = f.write
  749.         seek = f.seek
  750.  
  751.         write("a" * 35)
  752.         write("b" * 35)
  753.         seek(0, 0)
  754.         self.failUnless(read(70) == 'a'*35 + 'b'*35)
  755.  
  756.     def test_context_manager_before_rollover(self):
  757.         # A SpooledTemporaryFile can be used as a context manager
  758.         with tempfile.SpooledTemporaryFile(max_size=1) as f:
  759.             self.failIf(f._rolled)
  760.             self.failIf(f.closed)
  761.         self.failUnless(f.closed)
  762.         def use_closed():
  763.             with f:
  764.                 pass
  765.         self.failUnlessRaises(ValueError, use_closed)
  766.  
  767.     def test_context_manager_during_rollover(self):
  768.         # A SpooledTemporaryFile can be used as a context manager
  769.         with tempfile.SpooledTemporaryFile(max_size=1) as f:
  770.             self.failIf(f._rolled)
  771.             f.write('abc\n')
  772.             f.flush()
  773.             self.failUnless(f._rolled)
  774.             self.failIf(f.closed)
  775.         self.failUnless(f.closed)
  776.         def use_closed():
  777.             with f:
  778.                 pass
  779.         self.failUnlessRaises(ValueError, use_closed)
  780.  
  781.     def test_context_manager_after_rollover(self):
  782.         # A SpooledTemporaryFile can be used as a context manager
  783.         f = tempfile.SpooledTemporaryFile(max_size=1)
  784.         f.write('abc\n')
  785.         f.flush()
  786.         self.failUnless(f._rolled)
  787.         with f:
  788.             self.failIf(f.closed)
  789.         self.failUnless(f.closed)
  790.         def use_closed():
  791.             with f:
  792.                 pass
  793.         self.failUnlessRaises(ValueError, use_closed)
  794.  
  795.  
  796. test_classes.append(test_SpooledTemporaryFile)
  797.  
  798.  
  799. class test_TemporaryFile(TC):
  800.     """Test TemporaryFile()."""
  801.  
  802.     def test_basic(self):
  803.         # TemporaryFile can create files
  804.         # No point in testing the name params - the file has no name.
  805.         try:
  806.             tempfile.TemporaryFile()
  807.         except:
  808.             self.failOnException("TemporaryFile")
  809.  
  810.     def test_has_no_name(self):
  811.         # TemporaryFile creates files with no names (on this system)
  812.         dir = tempfile.mkdtemp()
  813.         f = tempfile.TemporaryFile(dir=dir)
  814.         f.write('blat')
  815.  
  816.         # Sneaky: because this file has no name, it should not prevent
  817.         # us from removing the directory it was created in.
  818.         try:
  819.             os.rmdir(dir)
  820.         except:
  821.             ei = sys.exc_info()
  822.             # cleanup
  823.             f.close()
  824.             os.rmdir(dir)
  825.             self.failOnException("rmdir", ei)
  826.  
  827.     def test_multiple_close(self):
  828.         # A TemporaryFile can be closed many times without error
  829.         f = tempfile.TemporaryFile()
  830.         f.write('abc\n')
  831.         f.close()
  832.         try:
  833.             f.close()
  834.             f.close()
  835.         except:
  836.             self.failOnException("close")
  837.  
  838.     # How to test the mode and bufsize parameters?
  839.  
  840.  
  841. if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile:
  842.     test_classes.append(test_TemporaryFile)
  843.  
  844. def test_main():
  845.     test_support.run_unittest(*test_classes)
  846.  
  847. if __name__ == "__main__":
  848.     test_main()
  849.