[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_tempfile.py

# tempfile.py unit tests.\r
import tempfile\r
import os\r
import sys\r
import re\r
import warnings\r
\r
import unittest\r
from test import test_support\r
\r
warnings.filterwarnings("ignore",\r
                        category=RuntimeWarning,\r
                        message="mktemp", module=__name__)\r
\r
if hasattr(os, 'stat'):\r
    import stat\r
    has_stat = 1\r
else:\r
    has_stat = 0\r
\r
has_textmode = (tempfile._text_openflags != tempfile._bin_openflags)\r
has_spawnl = hasattr(os, 'spawnl')\r
\r
# TEST_FILES may need to be tweaked for systems depending on the maximum\r
# number of files that can be opened at one time (see ulimit -n)\r
if sys.platform in ('openbsd3', 'openbsd4'):\r
    TEST_FILES = 48\r
else:\r
    TEST_FILES = 100\r
\r
# This is organized as one test for each chunk of code in tempfile.py,\r
# in order of their appearance in the file.  Testing which requires\r
# threads is not done here.\r
\r
# Common functionality.\r
class TC(unittest.TestCase):\r
\r
    str_check = re.compile(r"[a-zA-Z0-9_-]{6}$")\r
\r
    def failOnException(self, what, ei=None):\r
        if ei is None:\r
            ei = sys.exc_info()\r
        self.fail("%s raised %s: %s" % (what, ei[0], ei[1]))\r
\r
    def nameCheck(self, name, dir, pre, suf):\r
        (ndir, nbase) = os.path.split(name)\r
        npre  = nbase[:len(pre)]\r
        nsuf  = nbase[len(nbase)-len(suf):]\r
\r
        # check for equality of the absolute paths!\r
        self.assertEqual(os.path.abspath(ndir), os.path.abspath(dir),\r
                         "file '%s' not in directory '%s'" % (name, dir))\r
        self.assertEqual(npre, pre,\r
                         "file '%s' does not begin with '%s'" % (nbase, pre))\r
        self.assertEqual(nsuf, suf,\r
                         "file '%s' does not end with '%s'" % (nbase, suf))\r
\r
        nbase = nbase[len(pre):len(nbase)-len(suf)]\r
        self.assertTrue(self.str_check.match(nbase),\r
                     "random string '%s' does not match /^[a-zA-Z0-9_-]{6}$/"\r
                     % nbase)\r
\r
test_classes = []\r
\r
class test_exports(TC):\r
    def test_exports(self):\r
        # There are no surprising symbols in the tempfile module\r
        dict = tempfile.__dict__\r
\r
        expected = {\r
            "NamedTemporaryFile" : 1,\r
            "TemporaryFile" : 1,\r
            "mkstemp" : 1,\r
            "mkdtemp" : 1,\r
            "mktemp" : 1,\r
            "TMP_MAX" : 1,\r
            "gettempprefix" : 1,\r
            "gettempdir" : 1,\r
            "tempdir" : 1,\r
            "template" : 1,\r
            "SpooledTemporaryFile" : 1\r
        }\r
\r
        unexp = []\r
        for key in dict:\r
            if key[0] != '_' and key not in expected:\r
                unexp.append(key)\r
        self.assertTrue(len(unexp) == 0,\r
                        "unexpected keys: %s" % unexp)\r
\r
test_classes.append(test_exports)\r
\r
\r
class test__RandomNameSequence(TC):\r
    """Test the internal iterator object _RandomNameSequence."""\r
\r
    def setUp(self):\r
        self.r = tempfile._RandomNameSequence()\r
\r
    def test_get_six_char_str(self):\r
        # _RandomNameSequence returns a six-character string\r
        s = self.r.next()\r
        self.nameCheck(s, '', '', '')\r
\r
    def test_many(self):\r
        # _RandomNameSequence returns no duplicate strings (stochastic)\r
\r
        dict = {}\r
        r = self.r\r
        for i in xrange(TEST_FILES):\r
            s = r.next()\r
            self.nameCheck(s, '', '', '')\r
            self.assertNotIn(s, dict)\r
            dict[s] = 1\r
\r
    def test_supports_iter(self):\r
        # _RandomNameSequence supports the iterator protocol\r
\r
        i = 0\r
        r = self.r\r
        try:\r
            for s in r:\r
                i += 1\r
                if i == 20:\r
                    break\r
        except:\r
            self.failOnException("iteration")\r
\r
test_classes.append(test__RandomNameSequence)\r
\r
\r
class test__candidate_tempdir_list(TC):\r
    """Test the internal function _candidate_tempdir_list."""\r
\r
    def test_nonempty_list(self):\r
        # _candidate_tempdir_list returns a nonempty list of strings\r
\r
        cand = tempfile._candidate_tempdir_list()\r
\r
        self.assertFalse(len(cand) == 0)\r
        for c in cand:\r
            self.assertIsInstance(c, basestring)\r
\r
    def test_wanted_dirs(self):\r
        # _candidate_tempdir_list contains the expected directories\r
\r
        # Make sure the interesting environment variables are all set.\r
        with test_support.EnvironmentVarGuard() as env:\r
            for envname in 'TMPDIR', 'TEMP', 'TMP':\r
                dirname = os.getenv(envname)\r
                if not dirname:\r
                    env[envname] = os.path.abspath(envname)\r
\r
            cand = tempfile._candidate_tempdir_list()\r
\r
            for envname in 'TMPDIR', 'TEMP', 'TMP':\r
                dirname = os.getenv(envname)\r
                if not dirname: raise ValueError\r
                self.assertIn(dirname, cand)\r
\r
            try:\r
                dirname = os.getcwd()\r
            except (AttributeError, os.error):\r
                dirname = os.curdir\r
\r
            self.assertIn(dirname, cand)\r
\r
            # Not practical to try to verify the presence of OS-specific\r
            # paths in this list.\r
\r
test_classes.append(test__candidate_tempdir_list)\r
\r
\r
# We test _get_default_tempdir by testing gettempdir.\r
\r
\r
class test__get_candidate_names(TC):\r
    """Test the internal function _get_candidate_names."""\r
\r
    def test_retval(self):\r
        # _get_candidate_names returns a _RandomNameSequence object\r
        obj = tempfile._get_candidate_names()\r
        self.assertIsInstance(obj, tempfile._RandomNameSequence)\r
\r
    def test_same_thing(self):\r
        # _get_candidate_names always returns the same object\r
        a = tempfile._get_candidate_names()\r
        b = tempfile._get_candidate_names()\r
\r
        self.assertTrue(a is b)\r
\r
test_classes.append(test__get_candidate_names)\r
\r
\r
class test__mkstemp_inner(TC):\r
    """Test the internal function _mkstemp_inner."""\r
\r
    class mkstemped:\r
        _bflags = tempfile._bin_openflags\r
        _tflags = tempfile._text_openflags\r
        _close = os.close\r
        _unlink = os.unlink\r
\r
        def __init__(self, dir, pre, suf, bin):\r
            if bin: flags = self._bflags\r
            else:   flags = self._tflags\r
\r
            (self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags)\r
\r
        def write(self, str):\r
            os.write(self.fd, str)\r
\r
        def __del__(self):\r
            self._close(self.fd)\r
            self._unlink(self.name)\r
\r
    def do_create(self, dir=None, pre="", suf="", bin=1):\r
        if dir is None:\r
            dir = tempfile.gettempdir()\r
        try:\r
            file = self.mkstemped(dir, pre, suf, bin)\r
        except:\r
            self.failOnException("_mkstemp_inner")\r
\r
        self.nameCheck(file.name, dir, pre, suf)\r
        return file\r
\r
    def test_basic(self):\r
        # _mkstemp_inner can create files\r
        self.do_create().write("blat")\r
        self.do_create(pre="a").write("blat")\r
        self.do_create(suf="b").write("blat")\r
        self.do_create(pre="a", suf="b").write("blat")\r
        self.do_create(pre="aa", suf=".txt").write("blat")\r
\r
    def test_basic_many(self):\r
        # _mkstemp_inner can create many files (stochastic)\r
        extant = range(TEST_FILES)\r
        for i in extant:\r
            extant[i] = self.do_create(pre="aa")\r
\r
    def test_choose_directory(self):\r
        # _mkstemp_inner can create files in a user-selected directory\r
        dir = tempfile.mkdtemp()\r
        try:\r
            self.do_create(dir=dir).write("blat")\r
        finally:\r
            os.rmdir(dir)\r
\r
    def test_file_mode(self):\r
        # _mkstemp_inner creates files with the proper mode\r
        if not has_stat:\r
            return            # ugh, can't use SkipTest.\r
\r
        file = self.do_create()\r
        mode = stat.S_IMODE(os.stat(file.name).st_mode)\r
        expected = 0600\r
        if sys.platform in ('win32', 'os2emx'):\r
            # There's no distinction among 'user', 'group' and 'world';\r
            # replicate the 'user' bits.\r
            user = expected >> 6\r
            expected = user * (1 + 8 + 64)\r
        self.assertEqual(mode, expected)\r
\r
    def test_noinherit(self):\r
        # _mkstemp_inner file handles are not inherited by child processes\r
        if not has_spawnl:\r
            return            # ugh, can't use SkipTest.\r
\r
        if test_support.verbose:\r
            v="v"\r
        else:\r
            v="q"\r
\r
        file = self.do_create()\r
        fd = "%d" % file.fd\r
\r
        try:\r
            me = __file__\r
        except NameError:\r
            me = sys.argv[0]\r
\r
        # We have to exec something, so that FD_CLOEXEC will take\r
        # effect.  The core of this test is therefore in\r
        # tf_inherit_check.py, which see.\r
        tester = os.path.join(os.path.dirname(os.path.abspath(me)),\r
                              "tf_inherit_check.py")\r
\r
        # On Windows a spawn* /path/ with embedded spaces shouldn't be quoted,\r
        # but an arg with embedded spaces should be decorated with double\r
        # quotes on each end\r
        if sys.platform in ('win32',):\r
            decorated = '"%s"' % sys.executable\r
            tester = '"%s"' % tester\r
        else:\r
            decorated = sys.executable\r
\r
        retval = os.spawnl(os.P_WAIT, sys.executable, decorated, tester, v, fd)\r
        self.assertFalse(retval < 0,\r
                    "child process caught fatal signal %d" % -retval)\r
        self.assertFalse(retval > 0, "child process reports failure %d"%retval)\r
\r
    def test_textmode(self):\r
        # _mkstemp_inner can create files in text mode\r
        if not has_textmode:\r
            return            # ugh, can't use SkipTest.\r
\r
        self.do_create(bin=0).write("blat\n")\r
        # XXX should test that the file really is a text file\r
\r
test_classes.append(test__mkstemp_inner)\r
\r
\r
class test_gettempprefix(TC):\r
    """Test gettempprefix()."""\r
\r
    def test_sane_template(self):\r
        # gettempprefix returns a nonempty prefix string\r
        p = tempfile.gettempprefix()\r
\r
        self.assertIsInstance(p, basestring)\r
        self.assertTrue(len(p) > 0)\r
\r
    def test_usable_template(self):\r
        # gettempprefix returns a usable prefix string\r
\r
        # Create a temp directory, avoiding use of the prefix.\r
        # Then attempt to create a file whose name is\r
        # prefix + 'xxxxxx.xxx' in that directory.\r
        p = tempfile.gettempprefix() + "xxxxxx.xxx"\r
        d = tempfile.mkdtemp(prefix="")\r
        try:\r
            p = os.path.join(d, p)\r
            try:\r
                fd = os.open(p, os.O_RDWR | os.O_CREAT)\r
            except:\r
                self.failOnException("os.open")\r
            os.close(fd)\r
            os.unlink(p)\r
        finally:\r
            os.rmdir(d)\r
\r
test_classes.append(test_gettempprefix)\r
\r
\r
class test_gettempdir(TC):\r
    """Test gettempdir()."""\r
\r
    def test_directory_exists(self):\r
        # gettempdir returns a directory which exists\r
\r
        dir = tempfile.gettempdir()\r
        self.assertTrue(os.path.isabs(dir) or dir == os.curdir,\r
                     "%s is not an absolute path" % dir)\r
        self.assertTrue(os.path.isdir(dir),\r
                     "%s is not a directory" % dir)\r
\r
    def test_directory_writable(self):\r
        # gettempdir returns a directory writable by the user\r
\r
        # sneaky: just instantiate a NamedTemporaryFile, which\r
        # defaults to writing into the directory returned by\r
        # gettempdir.\r
        try:\r
            file = tempfile.NamedTemporaryFile()\r
            file.write("blat")\r
            file.close()\r
        except:\r
            self.failOnException("create file in %s" % tempfile.gettempdir())\r
\r
    def test_same_thing(self):\r
        # gettempdir always returns the same object\r
        a = tempfile.gettempdir()\r
        b = tempfile.gettempdir()\r
\r
        self.assertTrue(a is b)\r
\r
test_classes.append(test_gettempdir)\r
\r
\r
class test_mkstemp(TC):\r
    """Test mkstemp()."""\r
\r
    def do_create(self, dir=None, pre="", suf=""):\r
        if dir is None:\r
            dir = tempfile.gettempdir()\r
        try:\r
            (fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)\r
            (ndir, nbase) = os.path.split(name)\r
            adir = os.path.abspath(dir)\r
            self.assertEqual(adir, ndir,\r
                "Directory '%s' incorrectly returned as '%s'" % (adir, ndir))\r
        except:\r
            self.failOnException("mkstemp")\r
\r
        try:\r
            self.nameCheck(name, dir, pre, suf)\r
        finally:\r
            os.close(fd)\r
            os.unlink(name)\r
\r
    def test_basic(self):\r
        # mkstemp can create files\r
        self.do_create()\r
        self.do_create(pre="a")\r
        self.do_create(suf="b")\r
        self.do_create(pre="a", suf="b")\r
        self.do_create(pre="aa", suf=".txt")\r
        self.do_create(dir=".")\r
\r
    def test_choose_directory(self):\r
        # mkstemp can create directories in a user-selected directory\r
        dir = tempfile.mkdtemp()\r
        try:\r
            self.do_create(dir=dir)\r
        finally:\r
            os.rmdir(dir)\r
\r
test_classes.append(test_mkstemp)\r
\r
\r
class test_mkdtemp(TC):\r
    """Test mkdtemp()."""\r
\r
    def do_create(self, dir=None, pre="", suf=""):\r
        if dir is None:\r
            dir = tempfile.gettempdir()\r
        try:\r
            name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)\r
        except:\r
            self.failOnException("mkdtemp")\r
\r
        try:\r
            self.nameCheck(name, dir, pre, suf)\r
            return name\r
        except:\r
            os.rmdir(name)\r
            raise\r
\r
    def test_basic(self):\r
        # mkdtemp can create directories\r
        os.rmdir(self.do_create())\r
        os.rmdir(self.do_create(pre="a"))\r
        os.rmdir(self.do_create(suf="b"))\r
        os.rmdir(self.do_create(pre="a", suf="b"))\r
        os.rmdir(self.do_create(pre="aa", suf=".txt"))\r
\r
    def test_basic_many(self):\r
        # mkdtemp can create many directories (stochastic)\r
        extant = range(TEST_FILES)\r
        try:\r
            for i in extant:\r
                extant[i] = self.do_create(pre="aa")\r
        finally:\r
            for i in extant:\r
                if(isinstance(i, basestring)):\r
                    os.rmdir(i)\r
\r
    def test_choose_directory(self):\r
        # mkdtemp can create directories in a user-selected directory\r
        dir = tempfile.mkdtemp()\r
        try:\r
            os.rmdir(self.do_create(dir=dir))\r
        finally:\r
            os.rmdir(dir)\r
\r
    def test_mode(self):\r
        # mkdtemp creates directories with the proper mode\r
        if not has_stat:\r
            return            # ugh, can't use SkipTest.\r
\r
        dir = self.do_create()\r
        try:\r
            mode = stat.S_IMODE(os.stat(dir).st_mode)\r
            mode &= 0777 # Mask off sticky bits inherited from /tmp\r
            expected = 0700\r
            if sys.platform in ('win32', 'os2emx'):\r
                # There's no distinction among 'user', 'group' and 'world';\r
                # replicate the 'user' bits.\r
                user = expected >> 6\r
                expected = user * (1 + 8 + 64)\r
            self.assertEqual(mode, expected)\r
        finally:\r
            os.rmdir(dir)\r
\r
test_classes.append(test_mkdtemp)\r
\r
\r
class test_mktemp(TC):\r
    """Test mktemp()."""\r
\r
    # For safety, all use of mktemp must occur in a private directory.\r
    # We must also suppress the RuntimeWarning it generates.\r
    def setUp(self):\r
        self.dir = tempfile.mkdtemp()\r
\r
    def tearDown(self):\r
        if self.dir:\r
            os.rmdir(self.dir)\r
            self.dir = None\r
\r
    class mktemped:\r
        _unlink = os.unlink\r
        _bflags = tempfile._bin_openflags\r
\r
        def __init__(self, dir, pre, suf):\r
            self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)\r
            # Create the file.  This will raise an exception if it's\r
            # mysteriously appeared in the meanwhile.\r
            os.close(os.open(self.name, self._bflags, 0600))\r
\r
        def __del__(self):\r
            self._unlink(self.name)\r
\r
    def do_create(self, pre="", suf=""):\r
        try:\r
            file = self.mktemped(self.dir, pre, suf)\r
        except:\r
            self.failOnException("mktemp")\r
\r
        self.nameCheck(file.name, self.dir, pre, suf)\r
        return file\r
\r
    def test_basic(self):\r
        # mktemp can choose usable file names\r
        self.do_create()\r
        self.do_create(pre="a")\r
        self.do_create(suf="b")\r
        self.do_create(pre="a", suf="b")\r
        self.do_create(pre="aa", suf=".txt")\r
\r
    def test_many(self):\r
        # mktemp can choose many usable file names (stochastic)\r
        extant = range(TEST_FILES)\r
        for i in extant:\r
            extant[i] = self.do_create(pre="aa")\r
\r
##     def test_warning(self):\r
##         # mktemp issues a warning when used\r
##         warnings.filterwarnings("error",\r
##                                 category=RuntimeWarning,\r
##                                 message="mktemp")\r
##         self.assertRaises(RuntimeWarning,\r
##                           tempfile.mktemp, dir=self.dir)\r
\r
test_classes.append(test_mktemp)\r
\r
\r
# We test _TemporaryFileWrapper by testing NamedTemporaryFile.\r
\r
\r
class test_NamedTemporaryFile(TC):\r
    """Test NamedTemporaryFile()."""\r
\r
    def do_create(self, dir=None, pre="", suf="", delete=True):\r
        if dir is None:\r
            dir = tempfile.gettempdir()\r
        try:\r
            file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf,\r
                                               delete=delete)\r
        except:\r
            self.failOnException("NamedTemporaryFile")\r
\r
        self.nameCheck(file.name, dir, pre, suf)\r
        return file\r
\r
\r
    def test_basic(self):\r
        # NamedTemporaryFile can create files\r
        self.do_create()\r
        self.do_create(pre="a")\r
        self.do_create(suf="b")\r
        self.do_create(pre="a", suf="b")\r
        self.do_create(pre="aa", suf=".txt")\r
\r
    def test_creates_named(self):\r
        # NamedTemporaryFile creates files with names\r
        f = tempfile.NamedTemporaryFile()\r
        self.assertTrue(os.path.exists(f.name),\r
                        "NamedTemporaryFile %s does not exist" % f.name)\r
\r
    def test_del_on_close(self):\r
        # A NamedTemporaryFile is deleted when closed\r
        dir = tempfile.mkdtemp()\r
        try:\r
            f = tempfile.NamedTemporaryFile(dir=dir)\r
            f.write('blat')\r
            f.close()\r
            self.assertFalse(os.path.exists(f.name),\r
                        "NamedTemporaryFile %s exists after close" % f.name)\r
        finally:\r
            os.rmdir(dir)\r
\r
    def test_dis_del_on_close(self):\r
        # Tests that delete-on-close can be disabled\r
        dir = tempfile.mkdtemp()\r
        tmp = None\r
        try:\r
            f = tempfile.NamedTemporaryFile(dir=dir, delete=False)\r
            tmp = f.name\r
            f.write('blat')\r
            f.close()\r
            self.assertTrue(os.path.exists(f.name),\r
                        "NamedTemporaryFile %s missing after close" % f.name)\r
        finally:\r
            if tmp is not None:\r
                os.unlink(tmp)\r
            os.rmdir(dir)\r
\r
    def test_multiple_close(self):\r
        # A NamedTemporaryFile can be closed many times without error\r
        f = tempfile.NamedTemporaryFile()\r
        f.write('abc\n')\r
        f.close()\r
        try:\r
            f.close()\r
            f.close()\r
        except:\r
            self.failOnException("close")\r
\r
    def test_context_manager(self):\r
        # A NamedTemporaryFile can be used as a context manager\r
        with tempfile.NamedTemporaryFile() as f:\r
            self.assertTrue(os.path.exists(f.name))\r
        self.assertFalse(os.path.exists(f.name))\r
        def use_closed():\r
            with f:\r
                pass\r
        self.assertRaises(ValueError, use_closed)\r
\r
    # How to test the mode and bufsize parameters?\r
\r
test_classes.append(test_NamedTemporaryFile)\r
\r
class test_SpooledTemporaryFile(TC):\r
    """Test SpooledTemporaryFile()."""\r
\r
    def do_create(self, max_size=0, dir=None, pre="", suf=""):\r
        if dir is None:\r
            dir = tempfile.gettempdir()\r
        try:\r
            file = tempfile.SpooledTemporaryFile(max_size=max_size, dir=dir, prefix=pre, suffix=suf)\r
        except:\r
            self.failOnException("SpooledTemporaryFile")\r
\r
        return file\r
\r
\r
    def test_basic(self):\r
        # SpooledTemporaryFile can create files\r
        f = self.do_create()\r
        self.assertFalse(f._rolled)\r
        f = self.do_create(max_size=100, pre="a", suf=".txt")\r
        self.assertFalse(f._rolled)\r
\r
    def test_del_on_close(self):\r
        # A SpooledTemporaryFile is deleted when closed\r
        dir = tempfile.mkdtemp()\r
        try:\r
            f = tempfile.SpooledTemporaryFile(max_size=10, dir=dir)\r
            self.assertFalse(f._rolled)\r
            f.write('blat ' * 5)\r
            self.assertTrue(f._rolled)\r
            filename = f.name\r
            f.close()\r
            self.assertFalse(os.path.exists(filename),\r
                        "SpooledTemporaryFile %s exists after close" % filename)\r
        finally:\r
            os.rmdir(dir)\r
\r
    def test_rewrite_small(self):\r
        # A SpooledTemporaryFile can be written to multiple within the max_size\r
        f = self.do_create(max_size=30)\r
        self.assertFalse(f._rolled)\r
        for i in range(5):\r
            f.seek(0, 0)\r
            f.write('x' * 20)\r
        self.assertFalse(f._rolled)\r
\r
    def test_write_sequential(self):\r
        # A SpooledTemporaryFile should hold exactly max_size bytes, and roll\r
        # over afterward\r
        f = self.do_create(max_size=30)\r
        self.assertFalse(f._rolled)\r
        f.write('x' * 20)\r
        self.assertFalse(f._rolled)\r
        f.write('x' * 10)\r
        self.assertFalse(f._rolled)\r
        f.write('x')\r
        self.assertTrue(f._rolled)\r
\r
    def test_writelines(self):\r
        # Verify writelines with a SpooledTemporaryFile\r
        f = self.do_create()\r
        f.writelines((b'x', b'y', b'z'))\r
        f.seek(0)\r
        buf = f.read()\r
        self.assertEqual(buf, b'xyz')\r
\r
    def test_writelines_sequential(self):\r
        # A SpooledTemporaryFile should hold exactly max_size bytes, and roll\r
        # over afterward\r
        f = self.do_create(max_size=35)\r
        f.writelines((b'x' * 20, b'x' * 10, b'x' * 5))\r
        self.assertFalse(f._rolled)\r
        f.write(b'x')\r
        self.assertTrue(f._rolled)\r
\r
    def test_sparse(self):\r
        # A SpooledTemporaryFile that is written late in the file will extend\r
        # when that occurs\r
        f = self.do_create(max_size=30)\r
        self.assertFalse(f._rolled)\r
        f.seek(100, 0)\r
        self.assertFalse(f._rolled)\r
        f.write('x')\r
        self.assertTrue(f._rolled)\r
\r
    def test_fileno(self):\r
        # A SpooledTemporaryFile should roll over to a real file on fileno()\r
        f = self.do_create(max_size=30)\r
        self.assertFalse(f._rolled)\r
        self.assertTrue(f.fileno() > 0)\r
        self.assertTrue(f._rolled)\r
\r
    def test_multiple_close_before_rollover(self):\r
        # A SpooledTemporaryFile can be closed many times without error\r
        f = tempfile.SpooledTemporaryFile()\r
        f.write('abc\n')\r
        self.assertFalse(f._rolled)\r
        f.close()\r
        try:\r
            f.close()\r
            f.close()\r
        except:\r
            self.failOnException("close")\r
\r
    def test_multiple_close_after_rollover(self):\r
        # A SpooledTemporaryFile can be closed many times without error\r
        f = tempfile.SpooledTemporaryFile(max_size=1)\r
        f.write('abc\n')\r
        self.assertTrue(f._rolled)\r
        f.close()\r
        try:\r
            f.close()\r
            f.close()\r
        except:\r
            self.failOnException("close")\r
\r
    def test_bound_methods(self):\r
        # It should be OK to steal a bound method from a SpooledTemporaryFile\r
        # and use it independently; when the file rolls over, those bound\r
        # methods should continue to function\r
        f = self.do_create(max_size=30)\r
        read = f.read\r
        write = f.write\r
        seek = f.seek\r
\r
        write("a" * 35)\r
        write("b" * 35)\r
        seek(0, 0)\r
        self.assertTrue(read(70) == 'a'*35 + 'b'*35)\r
\r
    def test_context_manager_before_rollover(self):\r
        # A SpooledTemporaryFile can be used as a context manager\r
        with tempfile.SpooledTemporaryFile(max_size=1) as f:\r
            self.assertFalse(f._rolled)\r
            self.assertFalse(f.closed)\r
        self.assertTrue(f.closed)\r
        def use_closed():\r
            with f:\r
                pass\r
        self.assertRaises(ValueError, use_closed)\r
\r
    def test_context_manager_during_rollover(self):\r
        # A SpooledTemporaryFile can be used as a context manager\r
        with tempfile.SpooledTemporaryFile(max_size=1) as f:\r
            self.assertFalse(f._rolled)\r
            f.write('abc\n')\r
            f.flush()\r
            self.assertTrue(f._rolled)\r
            self.assertFalse(f.closed)\r
        self.assertTrue(f.closed)\r
        def use_closed():\r
            with f:\r
                pass\r
        self.assertRaises(ValueError, use_closed)\r
\r
    def test_context_manager_after_rollover(self):\r
        # A SpooledTemporaryFile can be used as a context manager\r
        f = tempfile.SpooledTemporaryFile(max_size=1)\r
        f.write('abc\n')\r
        f.flush()\r
        self.assertTrue(f._rolled)\r
        with f:\r
            self.assertFalse(f.closed)\r
        self.assertTrue(f.closed)\r
        def use_closed():\r
            with f:\r
                pass\r
        self.assertRaises(ValueError, use_closed)\r
\r
\r
test_classes.append(test_SpooledTemporaryFile)\r
\r
\r
class test_TemporaryFile(TC):\r
    """Test TemporaryFile()."""\r
\r
    def test_basic(self):\r
        # TemporaryFile can create files\r
        # No point in testing the name params - the file has no name.\r
        try:\r
            tempfile.TemporaryFile()\r
        except:\r
            self.failOnException("TemporaryFile")\r
\r
    def test_has_no_name(self):\r
        # TemporaryFile creates files with no names (on this system)\r
        dir = tempfile.mkdtemp()\r
        f = tempfile.TemporaryFile(dir=dir)\r
        f.write('blat')\r
\r
        # Sneaky: because this file has no name, it should not prevent\r
        # us from removing the directory it was created in.\r
        try:\r
            os.rmdir(dir)\r
        except:\r
            ei = sys.exc_info()\r
            # cleanup\r
            f.close()\r
            os.rmdir(dir)\r
            self.failOnException("rmdir", ei)\r
\r
    def test_multiple_close(self):\r
        # A TemporaryFile can be closed many times without error\r
        f = tempfile.TemporaryFile()\r
        f.write('abc\n')\r
        f.close()\r
        try:\r
            f.close()\r
            f.close()\r
        except:\r
            self.failOnException("close")\r
\r
    # How to test the mode and bufsize parameters?\r
\r
\r
if tempfile.NamedTemporaryFile is not tempfile.TemporaryFile:\r
    test_classes.append(test_TemporaryFile)\r
\r
def test_main():\r
    test_support.run_unittest(*test_classes)\r
\r
if __name__ == "__main__":\r
    test_main()\r