Lib/test/test_tempfile.py

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