home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / test_tempfile.py < prev    next >
Text File  |  2003-12-30  |  20KB  |  660 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.         # On Windows a spawn* /path/ with embedded spaces shouldn't be quoted,
  296.         # but an arg with embedded spaces should be decorated with double
  297.         # quotes on each end
  298.         if sys.platform in ('win32'):
  299.             decorated = '"%s"' % sys.executable
  300.             tester = '"%s"' % tester
  301.         else:
  302.             decorated = sys.executable
  303.  
  304.         retval = os.spawnl(os.P_WAIT, sys.executable, decorated, tester, v, fd)
  305.         self.failIf(retval < 0,
  306.                     "child process caught fatal signal %d" % -retval)
  307.         self.failIf(retval > 0, "child process reports failure")
  308.  
  309.     def test_textmode(self):
  310.         # _mkstemp_inner can create files in text mode
  311.         if not has_textmode:
  312.             return            # ugh, can't use TestSkipped.
  313.  
  314.         self.do_create(bin=0).write("blat\n")
  315.         # XXX should test that the file really is a text file
  316.  
  317. test_classes.append(test__mkstemp_inner)
  318.  
  319.  
  320. class test_gettempprefix(TC):
  321.     """Test gettempprefix()."""
  322.  
  323.     def test_sane_template(self):
  324.         # gettempprefix returns a nonempty prefix string
  325.         p = tempfile.gettempprefix()
  326.  
  327.         self.assert_(isinstance(p, basestring))
  328.         self.assert_(len(p) > 0)
  329.  
  330.     def test_usable_template(self):
  331.         # gettempprefix returns a usable prefix string
  332.  
  333.         # Create a temp directory, avoiding use of the prefix.
  334.         # Then attempt to create a file whose name is
  335.         # prefix + 'xxxxxx.xxx' in that directory.
  336.         p = tempfile.gettempprefix() + "xxxxxx.xxx"
  337.         d = tempfile.mkdtemp(prefix="")
  338.         try:
  339.             p = os.path.join(d, p)
  340.             try:
  341.                 fd = os.open(p, os.O_RDWR | os.O_CREAT)
  342.             except:
  343.                 self.failOnException("os.open")
  344.             os.close(fd)
  345.             os.unlink(p)
  346.         finally:
  347.             os.rmdir(d)
  348.  
  349. test_classes.append(test_gettempprefix)
  350.  
  351.  
  352. class test_gettempdir(TC):
  353.     """Test gettempdir()."""
  354.  
  355.     def test_directory_exists(self):
  356.         # gettempdir returns a directory which exists
  357.  
  358.         dir = tempfile.gettempdir()
  359.         self.assert_(os.path.isabs(dir) or dir == os.curdir,
  360.                      "%s is not an absolute path" % dir)
  361.         self.assert_(os.path.isdir(dir),
  362.                      "%s is not a directory" % dir)
  363.  
  364.     def test_directory_writable(self):
  365.         # gettempdir returns a directory writable by the user
  366.  
  367.         # sneaky: just instantiate a NamedTemporaryFile, which
  368.         # defaults to writing into the directory returned by
  369.         # gettempdir.
  370.         try:
  371.             file = tempfile.NamedTemporaryFile()
  372.             file.write("blat")
  373.             file.close()
  374.         except:
  375.             self.failOnException("create file in %s" % tempfile.gettempdir())
  376.  
  377.     def test_same_thing(self):
  378.         # gettempdir always returns the same object
  379.         a = tempfile.gettempdir()
  380.         b = tempfile.gettempdir()
  381.  
  382.         self.assert_(a is b)
  383.  
  384. test_classes.append(test_gettempdir)
  385.  
  386.  
  387. class test_mkstemp(TC):
  388.     """Test mkstemp()."""
  389.  
  390.     def do_create(self, dir=None, pre="", suf="", ):
  391.         if dir is None:
  392.             dir = tempfile.gettempdir()
  393.         try:
  394.             (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)
  395.         except:
  396.             self.failOnException("mkstemp")
  397.  
  398.         try:
  399.             self.nameCheck(name, dir, pre, suf)
  400.         finally:
  401.             os.close(fd)
  402.             os.unlink(name)
  403.  
  404.     def test_basic(self):
  405.         # mkstemp can create files
  406.         self.do_create()
  407.         self.do_create(pre="a")
  408.         self.do_create(suf="b")
  409.         self.do_create(pre="a", suf="b")
  410.         self.do_create(pre="aa", suf=".txt")
  411.  
  412.     def test_choose_directory(self):
  413.         # mkstemp can create directories in a user-selected directory
  414.         dir = tempfile.mkdtemp()
  415.         try:
  416.             self.do_create(dir=dir)
  417.         finally:
  418.             os.rmdir(dir)
  419.  
  420. test_classes.append(test_mkstemp)
  421.  
  422.  
  423. class test_mkdtemp(TC):
  424.     """Test mkdtemp()."""
  425.  
  426.     def do_create(self, dir=None, pre="", suf=""):
  427.         if dir is None:
  428.             dir = tempfile.gettempdir()
  429.         try:
  430.             name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)
  431.         except:
  432.             self.failOnException("mkdtemp")
  433.  
  434.         try:
  435.             self.nameCheck(name, dir, pre, suf)
  436.             return name
  437.         except:
  438.             os.rmdir(name)
  439.             raise
  440.  
  441.     def test_basic(self):
  442.         # mkdtemp can create directories
  443.         os.rmdir(self.do_create())
  444.         os.rmdir(self.do_create(pre="a"))
  445.         os.rmdir(self.do_create(suf="b"))
  446.         os.rmdir(self.do_create(pre="a", suf="b"))
  447.         os.rmdir(self.do_create(pre="aa", suf=".txt"))
  448.  
  449.     def test_basic_many(self):
  450.         # mkdtemp can create many directories (stochastic)
  451.         extant = range(TEST_FILES)
  452.         try:
  453.             for i in extant:
  454.                 extant[i] = self.do_create(pre="aa")
  455.         finally:
  456.             for i in extant:
  457.                 if(isinstance(i, basestring)):
  458.                     os.rmdir(i)
  459.  
  460.     def test_choose_directory(self):
  461.         # mkdtemp can create directories in a user-selected directory
  462.         dir = tempfile.mkdtemp()
  463.         try:
  464.             os.rmdir(self.do_create(dir=dir))
  465.         finally:
  466.             os.rmdir(dir)
  467.  
  468.     def test_mode(self):
  469.         # mkdtemp creates directories with the proper mode
  470.         if not has_stat:
  471.             return            # ugh, can't use TestSkipped.
  472.  
  473.         dir = self.do_create()
  474.         try:
  475.             mode = stat.S_IMODE(os.stat(dir).st_mode)
  476.             expected = 0700
  477.             if sys.platform in ('win32', 'os2emx', 'mac'):
  478.                 # There's no distinction among 'user', 'group' and 'world';
  479.                 # replicate the 'user' bits.
  480.                 user = expected >> 6
  481.                 expected = user * (1 + 8 + 64)
  482.             self.assertEqual(mode, expected)
  483.         finally:
  484.             os.rmdir(dir)
  485.  
  486. test_classes.append(test_mkdtemp)
  487.  
  488.  
  489. class test_mktemp(TC):
  490.     """Test mktemp()."""
  491.  
  492.     # For safety, all use of mktemp must occur in a private directory.
  493.     # We must also suppress the RuntimeWarning it generates.
  494.     def setUp(self):
  495.         self.dir = tempfile.mkdtemp()
  496.  
  497.     def tearDown(self):
  498.         if self.dir:
  499.             os.rmdir(self.dir)
  500.             self.dir = None
  501.  
  502.     class mktemped:
  503.         _unlink = os.unlink
  504.         _bflags = tempfile._bin_openflags
  505.  
  506.         def __init__(self, dir, pre, suf):
  507.             self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)
  508.             # Create the file.  This will raise an exception if it's
  509.             # mysteriously appeared in the meanwhile.
  510.             os.close(os.open(self.name, self._bflags, 0600))
  511.  
  512.         def __del__(self):
  513.             self._unlink(self.name)
  514.  
  515.     def do_create(self, pre="", suf=""):
  516.         try:
  517.             file = self.mktemped(self.dir, pre, suf)
  518.         except:
  519.             self.failOnException("mktemp")
  520.  
  521.         self.nameCheck(file.name, self.dir, pre, suf)
  522.         return file
  523.  
  524.     def test_basic(self):
  525.         # mktemp can choose usable file names
  526.         self.do_create()
  527.         self.do_create(pre="a")
  528.         self.do_create(suf="b")
  529.         self.do_create(pre="a", suf="b")
  530.         self.do_create(pre="aa", suf=".txt")
  531.  
  532.     def test_many(self):
  533.         # mktemp can choose many usable file names (stochastic)
  534.         extant = range(TEST_FILES)
  535.         for i in extant:
  536.             extant[i] = self.do_create(pre="aa")
  537.  
  538. ##     def test_warning(self):
  539. ##         # mktemp issues a warning when used
  540. ##         warnings.filterwarnings("error",
  541. ##                                 category=RuntimeWarning,
  542. ##                                 message="mktemp")
  543. ##         self.assertRaises(RuntimeWarning,
  544. ##                           tempfile.mktemp, dir=self.dir)
  545.  
  546. test_classes.append(test_mktemp)
  547.  
  548.  
  549. # We test _TemporaryFileWrapper by testing NamedTemporaryFile.
  550.  
  551.  
  552. class test_NamedTemporaryFile(TC):
  553.     """Test NamedTemporaryFile()."""
  554.  
  555.     def do_create(self, dir=None, pre="", suf=""):
  556.         if dir is None:
  557.             dir = tempfile.gettempdir()
  558.         try:
  559.             file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf)
  560.         except:
  561.             self.failOnException("NamedTemporaryFile")
  562.  
  563.         self.nameCheck(file.name, dir, pre, suf)
  564.         return file
  565.  
  566.  
  567.     def test_basic(self):
  568.         # NamedTemporaryFile can create files
  569.         self.do_create()
  570.         self.do_create(pre="a")
  571.         self.do_create(suf="b")
  572.         self.do_create(pre="a", suf="b")
  573.         self.do_create(pre="aa", suf=".txt")
  574.  
  575.     def test_creates_named(self):
  576.         # NamedTemporaryFile creates files with names
  577.         f = tempfile.NamedTemporaryFile()
  578.         self.failUnless(os.path.exists(f.name),
  579.                         "NamedTemporaryFile %s does not exist" % f.name)
  580.  
  581.     def test_del_on_close(self):
  582.         # A NamedTemporaryFile is deleted when closed
  583.         dir = tempfile.mkdtemp()
  584.         try:
  585.             f = tempfile.NamedTemporaryFile(dir=dir)
  586.             f.write('blat')
  587.             f.close()
  588.             self.failIf(os.path.exists(f.name),
  589.                         "NamedTemporaryFile %s exists after close" % f.name)
  590.         finally:
  591.             os.rmdir(dir)
  592.  
  593.     def test_multiple_close(self):
  594.         # A NamedTemporaryFile can be closed many times without error
  595.  
  596.         f = tempfile.NamedTemporaryFile()
  597.         f.write('abc\n')
  598.         f.close()
  599.         try:
  600.             f.close()
  601.             f.close()
  602.         except:
  603.             self.failOnException("close")
  604.  
  605.     # How to test the mode and bufsize parameters?
  606.  
  607. test_classes.append(test_NamedTemporaryFile)
  608.  
  609.  
  610. class test_TemporaryFile(TC):
  611.     """Test TemporaryFile()."""
  612.  
  613.     def test_basic(self):
  614.         # TemporaryFile can create files
  615.         # No point in testing the name params - the file has no name.
  616.         try:
  617.             tempfile.TemporaryFile()
  618.         except:
  619.             self.failOnException("TemporaryFile")
  620.  
  621.     def test_has_no_name(self):
  622.         # TemporaryFile creates files with no names (on this system)
  623.         dir = tempfile.mkdtemp()
  624.         f = tempfile.TemporaryFile(dir=dir)
  625.         f.write('blat')
  626.  
  627.         # Sneaky: because this file has no name, it should not prevent
  628.         # us from removing the directory it was created in.
  629.         try:
  630.             os.rmdir(dir)
  631.         except:
  632.             ei = sys.exc_info()
  633.             # cleanup
  634.             f.close()
  635.             os.rmdir(dir)
  636.             self.failOnException("rmdir", ei)
  637.  
  638.     def test_multiple_close(self):
  639.         # A TemporaryFile can be closed many times without error
  640.         f = tempfile.TemporaryFile()
  641.         f.write('abc\n')
  642.         f.close()
  643.         try:
  644.             f.close()
  645.             f.close()
  646.         except:
  647.             self.failOnException("close")
  648.  
  649.     # How to test the mode and bufsize parameters?
  650.  
  651.  
  652. if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile:
  653.     test_classes.append(test_TemporaryFile)
  654.  
  655. def test_main():
  656.     test_support.run_unittest(*test_classes)
  657.  
  658. if __name__ == "__main__":
  659.     test_main()
  660.