home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / pythonwin / python.exe / TEST_TEMPFILE.PY < prev    next >
Encoding:
Python Source  |  2003-05-01  |  19.6 KB  |  652 lines
  1. # tempfile.py unit tests.
  2.  
  3. import tempfile
  4. import os
  5. import sys
  6. import re
  7. import errno
  8. import warnings
  9.  
  10. import unittest
  11. from test import test_support
  12.  
  13. warnings.filterwarnings("ignore",
  14.                         category=RuntimeWarning,
  15.                         message="mktemp", module=__name__)
  16.  
  17. if hasattr(os, 'stat'):
  18.     import stat
  19.     has_stat = 1
  20. else:
  21.     has_stat = 0
  22.  
  23. has_textmode = (tempfile._text_openflags != tempfile._bin_openflags)
  24. has_spawnl = hasattr(os, 'spawnl')
  25.  
  26. # TEST_FILES may need to be tweaked for systems depending on the maximum
  27. # number of files that can be opened at one time (see ulimit -n)
  28. if sys.platform == 'mac':
  29.     TEST_FILES = 32
  30. else:
  31.     TEST_FILES = 100
  32.  
  33. # This is organized as one test for each chunk of code in tempfile.py,
  34. # in order of their appearance in the file.  Testing which requires
  35. # threads is not done here.
  36.  
  37. # Common functionality.
  38. class TC(unittest.TestCase):
  39.  
  40.     str_check = re.compile(r"[a-zA-Z0-9_-]{6}$")
  41.  
  42.     def failOnException(self, what, ei=None):
  43.         if ei is None:
  44.             ei = sys.exc_info()
  45.         self.fail("%s raised %s: %s" % (what, ei[0], ei[1]))
  46.  
  47.     def nameCheck(self, name, dir, pre, suf):
  48.         (ndir, nbase) = os.path.split(name)
  49.         npre  = nbase[:len(pre)]
  50.         nsuf  = nbase[len(nbase)-len(suf):]
  51.  
  52.         self.assertEqual(ndir, dir,
  53.                          "file '%s' not in directory '%s'" % (name, dir))
  54.         self.assertEqual(npre, pre,
  55.                          "file '%s' does not begin with '%s'" % (nbase, pre))
  56.         self.assertEqual(nsuf, suf,
  57.                          "file '%s' does not end with '%s'" % (nbase, suf))
  58.  
  59.         nbase = nbase[len(pre):len(nbase)-len(suf)]
  60.         self.assert_(self.str_check.match(nbase),
  61.                      "random string '%s' does not match /^[a-zA-Z0-9_-]{6}$/"
  62.                      % nbase)
  63.  
  64. test_classes = []
  65.  
  66. class test_exports(TC):
  67.     def test_exports(self):
  68.         # There are no surprising symbols in the tempfile module
  69.         dict = tempfile.__dict__
  70.  
  71.         expected = {
  72.             "NamedTemporaryFile" : 1,
  73.             "TemporaryFile" : 1,
  74.             "mkstemp" : 1,
  75.             "mkdtemp" : 1,
  76.             "mktemp" : 1,
  77.             "TMP_MAX" : 1,
  78.             "gettempprefix" : 1,
  79.             "gettempdir" : 1,
  80.             "tempdir" : 1,
  81.             "template" : 1
  82.         }
  83.  
  84.         unexp = []
  85.         for key in dict:
  86.             if key[0] != '_' and key not in expected:
  87.                 unexp.append(key)
  88.         self.failUnless(len(unexp) == 0,
  89.                         "unexpected keys: %s" % unexp)
  90.  
  91. test_classes.append(test_exports)
  92.  
  93.  
  94. class test__RandomNameSequence(TC):
  95.     """Test the internal iterator object _RandomNameSequence."""
  96.  
  97.     def setUp(self):
  98.         self.r = tempfile._RandomNameSequence()
  99.  
  100.     def test_get_six_char_str(self):
  101.         # _RandomNameSequence returns a six-character string
  102.         s = self.r.next()
  103.         self.nameCheck(s, '', '', '')
  104.  
  105.     def test_many(self):
  106.         # _RandomNameSequence returns no duplicate strings (stochastic)
  107.  
  108.         dict = {}
  109.         r = self.r
  110.         for i in xrange(TEST_FILES):
  111.             s = r.next()
  112.             self.nameCheck(s, '', '', '')
  113.             self.failIf(s in dict)
  114.             dict[s] = 1
  115.  
  116.     def test_supports_iter(self):
  117.         # _RandomNameSequence supports the iterator protocol
  118.  
  119.         i = 0
  120.         r = self.r
  121.         try:
  122.             for s in r:
  123.                 i += 1
  124.                 if i == 20:
  125.                     break
  126.         except:
  127.             failOnException("iteration")
  128.  
  129. test_classes.append(test__RandomNameSequence)
  130.  
  131.  
  132. class test__candidate_tempdir_list(TC):
  133.     """Test the internal function _candidate_tempdir_list."""
  134.  
  135.     def test_nonempty_list(self):
  136.         # _candidate_tempdir_list returns a nonempty list of strings
  137.  
  138.         cand = tempfile._candidate_tempdir_list()
  139.  
  140.         self.failIf(len(cand) == 0)
  141.         for c in cand:
  142.             self.assert_(isinstance(c, basestring),
  143.                          "%s is not a string" % c)
  144.  
  145.     def test_wanted_dirs(self):
  146.         # _candidate_tempdir_list contains the expected directories
  147.  
  148.         # Make sure the interesting environment variables are all set.
  149.         added = []
  150.         try:
  151.             for envname in 'TMPDIR', 'TEMP', 'TMP':
  152.                 dirname = os.getenv(envname)
  153.                 if not dirname:
  154.                     os.environ[envname] = os.path.abspath(envname)
  155.                     added.append(envname)
  156.  
  157.             cand = tempfile._candidate_tempdir_list()
  158.  
  159.             for envname in 'TMPDIR', 'TEMP', 'TMP':
  160.                 dirname = os.getenv(envname)
  161.                 if not dirname: raise ValueError
  162.                 self.assert_(dirname in cand)
  163.  
  164.             try:
  165.                 dirname = os.getcwd()
  166.             except (AttributeError, os.error):
  167.                 dirname = os.curdir
  168.  
  169.             self.assert_(dirname in cand)
  170.  
  171.             # Not practical to try to verify the presence of OS-specific
  172.             # paths in this list.
  173.         finally:
  174.             for p in added:
  175.                 del os.environ[p]
  176.  
  177. test_classes.append(test__candidate_tempdir_list)
  178.  
  179.  
  180. # We test _get_default_tempdir by testing gettempdir.
  181.  
  182.  
  183. class test__get_candidate_names(TC):
  184.     """Test the internal function _get_candidate_names."""
  185.  
  186.     def test_retval(self):
  187.         # _get_candidate_names returns a _RandomNameSequence object
  188.         obj = tempfile._get_candidate_names()
  189.         self.assert_(isinstance(obj, tempfile._RandomNameSequence))
  190.  
  191.     def test_same_thing(self):
  192.         # _get_candidate_names always returns the same object
  193.         a = tempfile._get_candidate_names()
  194.         b = tempfile._get_candidate_names()
  195.  
  196.         self.assert_(a is b)
  197.  
  198. test_classes.append(test__get_candidate_names)
  199.  
  200.  
  201. class test__mkstemp_inner(TC):
  202.     """Test the internal function _mkstemp_inner."""
  203.  
  204.     class mkstemped:
  205.         _bflags = tempfile._bin_openflags
  206.         _tflags = tempfile._text_openflags
  207.         _close = os.close
  208.         _unlink = os.unlink
  209.  
  210.         def __init__(self, dir, pre, suf, bin):
  211.             if bin: flags = self._bflags
  212.             else:   flags = self._tflags
  213.  
  214.             (self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags)
  215.  
  216.         def write(self, str):
  217.             os.write(self.fd, str)
  218.  
  219.         def __del__(self):
  220.             self._close(self.fd)
  221.             self._unlink(self.name)
  222.  
  223.     def do_create(self, dir=None, pre="", suf="", bin=1):
  224.         if dir is None:
  225.             dir = tempfile.gettempdir()
  226.         try:
  227.             file = self.mkstemped(dir, pre, suf, bin)
  228.         except:
  229.             self.failOnException("_mkstemp_inner")
  230.  
  231.         self.nameCheck(file.name, dir, pre, suf)
  232.         return file
  233.  
  234.     def test_basic(self):
  235.         # _mkstemp_inner can create files
  236.         self.do_create().write("blat")
  237.         self.do_create(pre="a").write("blat")
  238.         self.do_create(suf="b").write("blat")
  239.         self.do_create(pre="a", suf="b").write("blat")
  240.         self.do_create(pre="aa", suf=".txt").write("blat")
  241.  
  242.     def test_basic_many(self):
  243.         # _mkstemp_inner can create many files (stochastic)
  244.         extant = range(TEST_FILES)
  245.         for i in extant:
  246.             extant[i] = self.do_create(pre="aa")
  247.  
  248.     def test_choose_directory(self):
  249.         # _mkstemp_inner can create files in a user-selected directory
  250.         dir = tempfile.mkdtemp()
  251.         try:
  252.             self.do_create(dir=dir).write("blat")
  253.         finally:
  254.             os.rmdir(dir)
  255.  
  256.     def test_file_mode(self):
  257.         # _mkstemp_inner creates files with the proper mode
  258.         if not has_stat:
  259.             return            # ugh, can't use TestSkipped.
  260.  
  261.         file = self.do_create()
  262.         mode = stat.S_IMODE(os.stat(file.name).st_mode)
  263.         expected = 0600
  264.         if sys.platform in ('win32', 'os2emx', 'mac'):
  265.             # There's no distinction among 'user', 'group' and 'world';
  266.             # replicate the 'user' bits.
  267.             user = expected >> 6
  268.             expected = user * (1 + 8 + 64)
  269.         self.assertEqual(mode, expected)
  270.  
  271.     def test_noinherit(self):
  272.         # _mkstemp_inner file handles are not inherited by child processes
  273.         if not has_spawnl:
  274.             return            # ugh, can't use TestSkipped.
  275.  
  276.         if test_support.verbose:
  277.             v="v"
  278.         else:
  279.             v="q"
  280.  
  281.         file = self.do_create()
  282.         fd = "%d" % file.fd
  283.  
  284.         try:
  285.             me = __file__
  286.         except NameError:
  287.             me = sys.argv[0]
  288.  
  289.         # We have to exec something, so that FD_CLOEXEC will take
  290.         # effect.  The core of this test is therefore in
  291.         # tf_inherit_check.py, which see.
  292.         tester = os.path.join(os.path.dirname(os.path.abspath(me)),
  293.                               "tf_inherit_check.py")
  294.  
  295.         retval = os.spawnl(os.P_WAIT, sys.executable,
  296.                            sys.executable, tester, v, fd)
  297.         self.failIf(retval < 0,
  298.                     "child process caught fatal signal %d" % -retval)
  299.         self.failIf(retval > 0, "child process reports failure")
  300.  
  301.     def test_textmode(self):
  302.         # _mkstemp_inner can create files in text mode
  303.         if not has_textmode:
  304.             return            # ugh, can't use TestSkipped.
  305.  
  306.         self.do_create(bin=0).write("blat\n")
  307.         # XXX should test that the file really is a text file
  308.  
  309. test_classes.append(test__mkstemp_inner)
  310.  
  311.  
  312. class test_gettempprefix(TC):
  313.     """Test gettempprefix()."""
  314.  
  315.     def test_sane_template(self):
  316.         # gettempprefix returns a nonempty prefix string
  317.         p = tempfile.gettempprefix()
  318.  
  319.         self.assert_(isinstance(p, basestring))
  320.         self.assert_(len(p) > 0)
  321.  
  322.     def test_usable_template(self):
  323.         # gettempprefix returns a usable prefix string
  324.  
  325.         # Create a temp directory, avoiding use of the prefix.
  326.         # Then attempt to create a file whose name is
  327.         # prefix + 'xxxxxx.xxx' in that directory.
  328.         p = tempfile.gettempprefix() + "xxxxxx.xxx"
  329.         d = tempfile.mkdtemp(prefix="")
  330.         try:
  331.             p = os.path.join(d, p)
  332.             try:
  333.                 fd = os.open(p, os.O_RDWR | os.O_CREAT)
  334.             except:
  335.                 self.failOnException("os.open")
  336.             os.close(fd)
  337.             os.unlink(p)
  338.         finally:
  339.             os.rmdir(d)
  340.  
  341. test_classes.append(test_gettempprefix)
  342.  
  343.  
  344. class test_gettempdir(TC):
  345.     """Test gettempdir()."""
  346.  
  347.     def test_directory_exists(self):
  348.         # gettempdir returns a directory which exists
  349.  
  350.         dir = tempfile.gettempdir()
  351.         self.assert_(os.path.isabs(dir) or dir == os.curdir,
  352.                      "%s is not an absolute path" % dir)
  353.         self.assert_(os.path.isdir(dir),
  354.                      "%s is not a directory" % dir)
  355.  
  356.     def test_directory_writable(self):
  357.         # gettempdir returns a directory writable by the user
  358.  
  359.         # sneaky: just instantiate a NamedTemporaryFile, which
  360.         # defaults to writing into the directory returned by
  361.         # gettempdir.
  362.         try:
  363.             file = tempfile.NamedTemporaryFile()
  364.             file.write("blat")
  365.             file.close()
  366.         except:
  367.             self.failOnException("create file in %s" % tempfile.gettempdir())
  368.  
  369.     def test_same_thing(self):
  370.         # gettempdir always returns the same object
  371.         a = tempfile.gettempdir()
  372.         b = tempfile.gettempdir()
  373.  
  374.         self.assert_(a is b)
  375.  
  376. test_classes.append(test_gettempdir)
  377.  
  378.  
  379. class test_mkstemp(TC):
  380.     """Test mkstemp()."""
  381.  
  382.     def do_create(self, dir=None, pre="", suf="", ):
  383.         if dir is None:
  384.             dir = tempfile.gettempdir()
  385.         try:
  386.             (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)
  387.         except:
  388.             self.failOnException("mkstemp")
  389.  
  390.         try:
  391.             self.nameCheck(name, dir, pre, suf)
  392.         finally:
  393.             os.close(fd)
  394.             os.unlink(name)
  395.  
  396.     def test_basic(self):
  397.         # mkstemp can create files
  398.         self.do_create()
  399.         self.do_create(pre="a")
  400.         self.do_create(suf="b")
  401.         self.do_create(pre="a", suf="b")
  402.         self.do_create(pre="aa", suf=".txt")
  403.  
  404.     def test_choose_directory(self):
  405.         # mkstemp can create directories in a user-selected directory
  406.         dir = tempfile.mkdtemp()
  407.         try:
  408.             self.do_create(dir=dir)
  409.         finally:
  410.             os.rmdir(dir)
  411.  
  412. test_classes.append(test_mkstemp)
  413.  
  414.  
  415. class test_mkdtemp(TC):
  416.     """Test mkdtemp()."""
  417.  
  418.     def do_create(self, dir=None, pre="", suf=""):
  419.         if dir is None:
  420.             dir = tempfile.gettempdir()
  421.         try:
  422.             name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)
  423.         except:
  424.             self.failOnException("mkdtemp")
  425.  
  426.         try:
  427.             self.nameCheck(name, dir, pre, suf)
  428.             return name
  429.         except:
  430.             os.rmdir(name)
  431.             raise
  432.  
  433.     def test_basic(self):
  434.         # mkdtemp can create directories
  435.         os.rmdir(self.do_create())
  436.         os.rmdir(self.do_create(pre="a"))
  437.         os.rmdir(self.do_create(suf="b"))
  438.         os.rmdir(self.do_create(pre="a", suf="b"))
  439.         os.rmdir(self.do_create(pre="aa", suf=".txt"))
  440.  
  441.     def test_basic_many(self):
  442.         # mkdtemp can create many directories (stochastic)
  443.         extant = range(TEST_FILES)
  444.         try:
  445.             for i in extant:
  446.                 extant[i] = self.do_create(pre="aa")
  447.         finally:
  448.             for i in extant:
  449.                 if(isinstance(i, basestring)):
  450.                     os.rmdir(i)
  451.  
  452.     def test_choose_directory(self):
  453.         # mkdtemp can create directories in a user-selected directory
  454.         dir = tempfile.mkdtemp()
  455.         try:
  456.             os.rmdir(self.do_create(dir=dir))
  457.         finally:
  458.             os.rmdir(dir)
  459.  
  460.     def test_mode(self):
  461.         # mkdtemp creates directories with the proper mode
  462.         if not has_stat:
  463.             return            # ugh, can't use TestSkipped.
  464.  
  465.         dir = self.do_create()
  466.         try:
  467.             mode = stat.S_IMODE(os.stat(dir).st_mode)
  468.             expected = 0700
  469.             if sys.platform in ('win32', 'os2emx', 'mac'):
  470.                 # There's no distinction among 'user', 'group' and 'world';
  471.                 # replicate the 'user' bits.
  472.                 user = expected >> 6
  473.                 expected = user * (1 + 8 + 64)
  474.             self.assertEqual(mode, expected)
  475.         finally:
  476.             os.rmdir(dir)
  477.  
  478. test_classes.append(test_mkdtemp)
  479.  
  480.  
  481. class test_mktemp(TC):
  482.     """Test mktemp()."""
  483.  
  484.     # For safety, all use of mktemp must occur in a private directory.
  485.     # We must also suppress the RuntimeWarning it generates.
  486.     def setUp(self):
  487.         self.dir = tempfile.mkdtemp()
  488.  
  489.     def tearDown(self):
  490.         if self.dir:
  491.             os.rmdir(self.dir)
  492.             self.dir = None
  493.  
  494.     class mktemped:
  495.         _unlink = os.unlink
  496.         _bflags = tempfile._bin_openflags
  497.  
  498.         def __init__(self, dir, pre, suf):
  499.             self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)
  500.             # Create the file.  This will raise an exception if it's
  501.             # mysteriously appeared in the meanwhile.
  502.             os.close(os.open(self.name, self._bflags, 0600))
  503.  
  504.         def __del__(self):
  505.             self._unlink(self.name)
  506.  
  507.     def do_create(self, pre="", suf=""):
  508.         try:
  509.             file = self.mktemped(self.dir, pre, suf)
  510.         except:
  511.             self.failOnException("mktemp")
  512.  
  513.         self.nameCheck(file.name, self.dir, pre, suf)
  514.         return file
  515.  
  516.     def test_basic(self):
  517.         # mktemp can choose usable file names
  518.         self.do_create()
  519.         self.do_create(pre="a")
  520.         self.do_create(suf="b")
  521.         self.do_create(pre="a", suf="b")
  522.         self.do_create(pre="aa", suf=".txt")
  523.  
  524.     def test_many(self):
  525.         # mktemp can choose many usable file names (stochastic)
  526.         extant = range(TEST_FILES)
  527.         for i in extant:
  528.             extant[i] = self.do_create(pre="aa")
  529.  
  530. ##     def test_warning(self):
  531. ##         # mktemp issues a warning when used
  532. ##         warnings.filterwarnings("error",
  533. ##                                 category=RuntimeWarning,
  534. ##                                 message="mktemp")
  535. ##         self.assertRaises(RuntimeWarning,
  536. ##                           tempfile.mktemp, dir=self.dir)
  537.  
  538. test_classes.append(test_mktemp)
  539.  
  540.  
  541. # We test _TemporaryFileWrapper by testing NamedTemporaryFile.
  542.  
  543.  
  544. class test_NamedTemporaryFile(TC):
  545.     """Test NamedTemporaryFile()."""
  546.  
  547.     def do_create(self, dir=None, pre="", suf=""):
  548.         if dir is None:
  549.             dir = tempfile.gettempdir()
  550.         try:
  551.             file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf)
  552.         except:
  553.             self.failOnException("NamedTemporaryFile")
  554.  
  555.         self.nameCheck(file.name, dir, pre, suf)
  556.         return file
  557.  
  558.  
  559.     def test_basic(self):
  560.         # NamedTemporaryFile can create files
  561.         self.do_create()
  562.         self.do_create(pre="a")
  563.         self.do_create(suf="b")
  564.         self.do_create(pre="a", suf="b")
  565.         self.do_create(pre="aa", suf=".txt")
  566.  
  567.     def test_creates_named(self):
  568.         # NamedTemporaryFile creates files with names
  569.         f = tempfile.NamedTemporaryFile()
  570.         self.failUnless(os.path.exists(f.name),
  571.                         "NamedTemporaryFile %s does not exist" % f.name)
  572.  
  573.     def test_del_on_close(self):
  574.         # A NamedTemporaryFile is deleted when closed
  575.         dir = tempfile.mkdtemp()
  576.         try:
  577.             f = tempfile.NamedTemporaryFile(dir=dir)
  578.             f.write('blat')
  579.             f.close()
  580.             self.failIf(os.path.exists(f.name),
  581.                         "NamedTemporaryFile %s exists after close" % f.name)
  582.         finally:
  583.             os.rmdir(dir)
  584.  
  585.     def test_multiple_close(self):
  586.         # A NamedTemporaryFile can be closed many times without error
  587.  
  588.         f = tempfile.NamedTemporaryFile()
  589.         f.write('abc\n')
  590.         f.close()
  591.         try:
  592.             f.close()
  593.             f.close()
  594.         except:
  595.             self.failOnException("close")
  596.  
  597.     # How to test the mode and bufsize parameters?
  598.  
  599. test_classes.append(test_NamedTemporaryFile)
  600.  
  601.  
  602. class test_TemporaryFile(TC):
  603.     """Test TemporaryFile()."""
  604.  
  605.     def test_basic(self):
  606.         # TemporaryFile can create files
  607.         # No point in testing the name params - the file has no name.
  608.         try:
  609.             tempfile.TemporaryFile()
  610.         except:
  611.             self.failOnException("TemporaryFile")
  612.  
  613.     def test_has_no_name(self):
  614.         # TemporaryFile creates files with no names (on this system)
  615.         dir = tempfile.mkdtemp()
  616.         f = tempfile.TemporaryFile(dir=dir)
  617.         f.write('blat')
  618.  
  619.         # Sneaky: because this file has no name, it should not prevent
  620.         # us from removing the directory it was created in.
  621.         try:
  622.             os.rmdir(dir)
  623.         except:
  624.             ei = sys.exc_info()
  625.             # cleanup
  626.             f.close()
  627.             os.rmdir(dir)
  628.             self.failOnException("rmdir", ei)
  629.  
  630.     def test_multiple_close(self):
  631.         # A TemporaryFile can be closed many times without error
  632.         f = tempfile.TemporaryFile()
  633.         f.write('abc\n')
  634.         f.close()
  635.         try:
  636.             f.close()
  637.             f.close()
  638.         except:
  639.             self.failOnException("close")
  640.  
  641.     # How to test the mode and bufsize parameters?
  642.  
  643.  
  644. if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile:
  645.     test_classes.append(test_TemporaryFile)
  646.  
  647. def test_main():
  648.     test_support.run_unittest(*test_classes)
  649.  
  650. if __name__ == "__main__":
  651.     test_main()
  652.