def test_infer_return_type_singles(self):

self.assertIs(str, tempfile._infer_return_type(''))

self.assertIs(bytes, tempfile._infer_return_type(b''))

self.assertIs(str, tempfile._infer_return_type(None))

def test_infer_return_type_multiples(self):

self.assertIs(str, tempfile._infer_return_type('', ''))

self.assertIs(bytes, tempfile._infer_return_type(b'', b''))

with self.assertRaises(TypeError):

tempfile._infer_return_type('', b'')

with self.assertRaises(TypeError):

tempfile._infer_return_type(b'', '')

def test_infer_return_type_multiples_and_none(self):

self.assertIs(str, tempfile._infer_return_type(None, ''))

self.assertIs(str, tempfile._infer_return_type('', None))

self.assertIs(str, tempfile._infer_return_type(None, None))

self.assertIs(bytes, tempfile._infer_return_type(b'', None))

self.assertIs(bytes, tempfile._infer_return_type(None, b''))

with self.assertRaises(TypeError):

tempfile._infer_return_type('', None, b'')

with self.assertRaises(TypeError):

tempfile._infer_return_type(b'', None, '')

def test_infer_return_type_pathlib(self):

self.assertIs(str, tempfile._infer_return_type(os_helper.FakePath('/')))

def test_infer_return_type_pathlike(self):

Path = os_helper.FakePath

self.assertIs(str, tempfile._infer_return_type(Path('/')))

self.assertIs(bytes, tempfile._infer_return_type(Path(b'/')))

self.assertIs(str, tempfile._infer_return_type('', Path('')))

self.assertIs(bytes, tempfile._infer_return_type(b'', Path(b'')))

self.assertIs(bytes, tempfile._infer_return_type(None, Path(b'')))

self.assertIs(str, tempfile._infer_return_type(None, Path('')))

with self.assertRaises(TypeError):

tempfile._infer_return_type('', Path(b''))

with self.assertRaises(TypeError):

str_check = re.compile(r"^[a-z0-9_-]{8}$")

b_check = re.compile(br"^[a-z0-9_-]{8}$")

def setUp(self):

self.enterContext(warnings_helper.check_warnings())

warnings.filterwarnings("ignore", category=RuntimeWarning,

message="mktemp", module=__name__)

def nameCheck(self, name, dir, pre, suf):

(ndir, nbase) = os.path.split(name)

npre = nbase[:len(pre)]

nsuf = nbase[len(nbase)-len(suf):]

if dir is not None:

self.assertIs(

type(name),

str

if type(dir) is str or isinstance(dir, os.PathLike) else

bytes,

"unexpected return type",

)

if pre is not None:

self.assertIs(type(name), str if type(pre) is str else bytes,

"unexpected return type")

if suf is not None:

self.assertIs(type(name), str if type(suf) is str else bytes,

"unexpected return type")

if (dir, pre, suf) == (None, None, None):

self.assertIs(type(name), str, "default return type must be str")

# check for equality of the absolute paths!

self.assertEqual(os.path.abspath(ndir), os.path.abspath(dir),

"file %r not in directory %r" % (name, dir))

self.assertEqual(npre, pre,

"file %r does not begin with %r" % (nbase, pre))

self.assertEqual(nsuf, suf,

"file %r does not end with %r" % (nbase, suf))

nbase = nbase[len(pre):len(nbase)-len(suf)]

check = self.str_check if isinstance(nbase, str) else self.b_check

self.assertTrue(check.match(nbase),

"random characters %r do not match %r"

def test_exports(self):

# There are no surprising symbols in the tempfile module

dict = tempfile.__dict__

expected = {

"NamedTemporaryFile" : 1,

"TemporaryFile" : 1,

"mkstemp" : 1,

"mkdtemp" : 1,

"mktemp" : 1,

"TMP_MAX" : 1,

"gettempprefix" : 1,

"gettempprefixb" : 1,

"gettempdir" : 1,

"gettempdirb" : 1,

"tempdir" : 1,

"template" : 1,

"SpooledTemporaryFile" : 1,

"TemporaryDirectory" : 1,

"TemporaryFileWrapper" : 1,

}

unexp = []

for key in dict:

if key[0] != '_' and key not in expected:

unexp.append(key)

self.assertTrue(len(unexp) == 0,

"""Test the internal iterator object _RandomNameSequence."""

def setUp(self):

self.r = tempfile._RandomNameSequence()

super().setUp()

def test_get_eight_char_str(self):

# _RandomNameSequence returns a eight-character string

s = next(self.r)

self.nameCheck(s, '', '', '')

def test_many(self):

# _RandomNameSequence returns no duplicate strings (stochastic)

dict = {}

r = self.r

for i in range(TEST_FILES):

s = next(r)

self.nameCheck(s, '', '', '')

self.assertNotIn(s, dict)

dict[s] = 1

def supports_iter(self):

# _RandomNameSequence supports the iterator protocol

i = 0

r = self.r

for s in r:

i += 1

if i == 20:

break

@support.requires_fork()

def test_process_awareness(self):

# ensure that the random source differs between

# child and parent.

read_fd, write_fd = os.pipe()

pid = None

try:

pid = os.fork()

if not pid:

# child process

os.close(read_fd)

os.write(write_fd, next(self.r).encode("ascii"))

os.close(write_fd)

# bypass the normal exit handlers- leave those to

# the parent.

os._exit(0)

# parent process

parent_value = next(self.r)

child_value = os.read(read_fd, len(parent_value)).decode("ascii")

finally:

if pid:

support.wait_process(pid, exitcode=0)

os.close(read_fd)

os.close(write_fd)

"""Test the internal function _candidate_tempdir_list."""

def test_nonempty_list(self):

# _candidate_tempdir_list returns a nonempty list of strings

cand = tempfile._candidate_tempdir_list()

self.assertFalse(len(cand) == 0)

for c in cand:

self.assertIsInstance(c, str)

def test_wanted_dirs(self):

# _candidate_tempdir_list contains the expected directories

# Make sure the interesting environment variables are all set.

with os_helper.EnvironmentVarGuard() as env:

for envname in 'TMPDIR', 'TEMP', 'TMP':

dirname = os.getenv(envname)

if not dirname:

env[envname] = os.path.abspath(envname)

cand = tempfile._candidate_tempdir_list()

for envname in 'TMPDIR', 'TEMP', 'TMP':

dirname = os.getenv(envname)

if not dirname: raise ValueError

self.assertIn(dirname, cand)

try:

dirname = os.getcwd()

except (AttributeError, OSError):

dirname = os.curdir

self.assertIn(dirname, cand)

# Not practical to try to verify the presence of OS-specific

"""Test _get_default_tempdir()."""

def test_no_files_left_behind(self):

# use a private empty directory

with tempfile.TemporaryDirectory() as our_temp_directory:

# force _get_default_tempdir() to consider our empty directory

def our_candidate_list():

return [our_temp_directory]

with support.swap_attr(tempfile, "_candidate_tempdir_list",

our_candidate_list):

# verify our directory is empty after _get_default_tempdir()

tempfile._get_default_tempdir()

self.assertEqual(os.listdir(our_temp_directory), [])

def raise_OSError(*args, **kwargs):

raise OSError()

with support.swap_attr(os, "open", raise_OSError):

# test again with failing os.open()

with self.assertRaises(FileNotFoundError):

tempfile._get_default_tempdir()

self.assertEqual(os.listdir(our_temp_directory), [])

with support.swap_attr(os, "write", raise_OSError):

# test again with failing os.write()

with self.assertRaises(FileNotFoundError):

tempfile._get_default_tempdir()

"""Test the internal function _get_candidate_names."""

def test_retval(self):

# _get_candidate_names returns a _RandomNameSequence object

obj = tempfile._get_candidate_names()

self.assertIsInstance(obj, tempfile._RandomNameSequence)

def test_same_thing(self):

# _get_candidate_names always returns the same object

a = tempfile._get_candidate_names()

b = tempfile._get_candidate_names()

dir = tempfile.mkdtemp()

try:

with support.swap_attr(tempfile, 'tempdir', dir):

yield

finally:

def test_read_only_directory(self):

with _inside_empty_temp_dir():

probe = os.path.join(tempfile.tempdir, 'probe')

if os.name == 'nt':

# Use security identifier *S-1-1-0 instead

# of localized "Everyone" to not depend on the locale.

cmd = ['icacls', tempfile.tempdir, '/deny', '*S-1-1-0:(W)']

stdout = None if support.verbose > 1 else subprocess.DEVNULL

subprocess.run(cmd, check=True, stdout=stdout)

else:

oldmode = mode = os.stat(tempfile.tempdir).st_mode

mode &= ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)

mode = stat.S_IREAD

os.chmod(tempfile.tempdir, mode)

try:

# Check that the directory is read-only.

try:

os.mkdir(probe)

except PermissionError:

pass

else:

os.rmdir(probe)

self.skipTest("can't set the directory read-only")

# gh-66305: Now it takes a split second, but previously

# it took about 10 days on Windows.

with self.assertRaises(PermissionError):

self.make_temp()

finally:

if os.name == 'nt':

# Use security identifier *S-1-1-0 instead

# of localized "Everyone" to not depend on the locale.

cmd = ['icacls', tempfile.tempdir, '/grant:r', '*S-1-1-0:(M)']

subprocess.run(cmd, check=True, stdout=stdout)

else:

os.chmod(tempfile.tempdir, oldmode)

self.assertEqual(os.listdir(tempfile.tempdir), [])

def test_nonexisting_directory(self):

with _inside_empty_temp_dir():

tempdir = os.path.join(tempfile.tempdir, 'nonexistent')

with support.swap_attr(tempfile, 'tempdir', tempdir):

with self.assertRaises(FileNotFoundError):

self.make_temp()

def test_non_directory(self):

with _inside_empty_temp_dir():

tempdir = os.path.join(tempfile.tempdir, 'file')

open(tempdir, 'wb').close()

with support.swap_attr(tempfile, 'tempdir', tempdir):

with self.assertRaises((NotADirectoryError, FileNotFoundError)):

"""Test the internal function _mkstemp_inner."""

class mkstemped:

_bflags = tempfile._bin_openflags

_tflags = tempfile._text_openflags

_close = os.close

_unlink = os.unlink

def __init__(self, dir, pre, suf, bin):

if bin: flags = self._bflags

else: flags = self._tflags

output_type = tempfile._infer_return_type(dir, pre, suf)

(self.fd, self.name) = tempfile._mkstemp_inner(dir, pre, suf, flags, output_type)

def write(self, str):

os.write(self.fd, str)

def __del__(self):

self._close(self.fd)

self._unlink(self.name)

def do_create(self, dir=None, pre=None, suf=None, bin=1):

output_type = tempfile._infer_return_type(dir, pre, suf)

if dir is None:

if output_type is str:

dir = tempfile.gettempdir()

else:

dir = tempfile.gettempdirb()

if pre is None:

pre = output_type()

if suf is None:

suf = output_type()

file = self.mkstemped(dir, pre, suf, bin)

self.nameCheck(file.name, dir, pre, suf)

return file

def test_basic(self):

# _mkstemp_inner can create files

self.do_create().write(b"blat")

self.do_create(pre="a").write(b"blat")

self.do_create(suf="b").write(b"blat")

self.do_create(pre="a", suf="b").write(b"blat")

self.do_create(pre="aa", suf=".txt").write(b"blat")

def test_basic_with_bytes_names(self):

# _mkstemp_inner can create files when given name parts all

# specified as bytes.

dir_b = tempfile.gettempdirb()

self.do_create(dir=dir_b, suf=b"").write(b"blat")

self.do_create(dir=dir_b, pre=b"a").write(b"blat")

self.do_create(dir=dir_b, suf=b"b").write(b"blat")

self.do_create(dir=dir_b, pre=b"a", suf=b"b").write(b"blat")

self.do_create(dir=dir_b, pre=b"aa", suf=b".txt").write(b"blat")

# Can't mix str & binary types in the args.

with self.assertRaises(TypeError):

self.do_create(dir="", suf=b"").write(b"blat")

with self.assertRaises(TypeError):

self.do_create(dir=dir_b, pre="").write(b"blat")

with self.assertRaises(TypeError):

self.do_create(dir=dir_b, pre=b"", suf="").write(b"blat")

def test_basic_many(self):

# _mkstemp_inner can create many files (stochastic)

extant = list(range(TEST_FILES))

for i in extant:

extant[i] = self.do_create(pre="aa")

def test_choose_directory(self):

# _mkstemp_inner can create files in a user-selected directory

dir = tempfile.mkdtemp()

try:

self.do_create(dir=dir).write(b"blat")

self.do_create(dir=os_helper.FakePath(dir)).write(b"blat")

finally:

support.gc_collect() # For PyPy or other GCs.

os.rmdir(dir)

@os_helper.skip_unless_working_chmod

def test_file_mode(self):

# _mkstemp_inner creates files with the proper mode

file = self.do_create()

mode = stat.S_IMODE(os.stat(file.name).st_mode)

expected = 0o600

if sys.platform == 'win32':

# There's no distinction among 'user', 'group' and 'world';

# replicate the 'user' bits.

user = expected >> 6

expected = user * (1 + 8 + 64)

self.assertEqual(mode, expected)

@unittest.skipUnless(has_spawnl, 'os.spawnl not available')

@support.requires_subprocess()

def test_noinherit(self):

# _mkstemp_inner file handles are not inherited by child processes

if support.verbose:

v="v"

else:

v="q"

file = self.do_create()

self.assertEqual(os.get_inheritable(file.fd), False)

fd = "%d" % file.fd

try:

me = __file__

except NameError:

me = sys.argv[0]

# We have to exec something, so that FD_CLOEXEC will take

# effect. The core of this test is therefore in

# tf_inherit_check.py, which see.

tester = os.path.join(os.path.dirname(os.path.abspath(me)),

"tf_inherit_check.py")

# On Windows a spawn* /path/ with embedded spaces shouldn't be quoted,

# but an arg with embedded spaces should be decorated with double

# quotes on each end

if sys.platform == 'win32':

decorated = '"%s"' % sys.executable

tester = '"%s"' % tester

else:

decorated = sys.executable

retval = os.spawnl(os.P_WAIT, sys.executable, decorated, tester, v, fd)

self.assertFalse(retval < 0,

"child process caught fatal signal %d" % -retval)

self.assertFalse(retval > 0, "child process reports failure %d"%retval)

@unittest.skipUnless(has_textmode, "text mode not available")

@unittest.skipIf(sys.platform == "cygwin",

def test_textmode(self):

# _mkstemp_inner can create files in text mode

# A text file is truncated at the first Ctrl+Z byte

f = self.do_create(bin=0)

f.write(b"blat\x1a")

f.write(b"extra\n")

os.lseek(f.fd, 0, os.SEEK_SET)

self.assertEqual(os.read(f.fd, 20), b"blat")

def make_temp(self):

return tempfile._mkstemp_inner(tempfile.gettempdir(),

tempfile.gettempprefix(),

'',

tempfile._bin_openflags,

str)

def test_collision_with_existing_file(self):

# _mkstemp_inner tries another name when a file with

# the chosen name already exists

with _inside_empty_temp_dir(), \

_mock_candidate_names('aaa', 'aaa', 'bbb'):

(fd1, name1) = self.make_temp()

os.close(fd1)

self.assertEndsWith(name1, 'aaa')

(fd2, name2) = self.make_temp()

os.close(fd2)

self.assertEndsWith(name2, 'bbb')

def test_collision_with_existing_directory(self):

# _mkstemp_inner tries another name when a directory with

# the chosen name already exists

with _inside_empty_temp_dir(), \

_mock_candidate_names('aaa', 'aaa', 'bbb'):

dir = tempfile.mkdtemp()

self.assertEndsWith(dir, 'aaa')

(fd, name) = self.make_temp()

os.close(fd)

"""Test gettempprefix()."""

def test_sane_template(self):

# gettempprefix returns a nonempty prefix string

p = tempfile.gettempprefix()

self.assertIsInstance(p, str)

self.assertGreater(len(p), 0)

pb = tempfile.gettempprefixb()

self.assertIsInstance(pb, bytes)

self.assertGreater(len(pb), 0)

def test_usable_template(self):

# gettempprefix returns a usable prefix string

# Create a temp directory, avoiding use of the prefix.

# Then attempt to create a file whose name is

# prefix + 'xxxxxx.xxx' in that directory.

p = tempfile.gettempprefix() + "xxxxxx.xxx"

d = tempfile.mkdtemp(prefix="")

try:

p = os.path.join(d, p)

fd = os.open(p, os.O_RDWR | os.O_CREAT)

os.close(fd)

os.unlink(p)

finally:

"""Test gettempdir()."""

def test_directory_exists(self):

# gettempdir returns a directory which exists

for d in (tempfile.gettempdir(), tempfile.gettempdirb()):

self.assertTrue(os.path.isabs(d) or d == os.curdir,

"%r is not an absolute path" % d)

self.assertTrue(os.path.isdir(d),

"%r is not a directory" % d)

def test_directory_writable(self):

# gettempdir returns a directory writable by the user

# sneaky: just instantiate a NamedTemporaryFile, which

# defaults to writing into the directory returned by

# gettempdir.

with tempfile.NamedTemporaryFile() as file:

file.write(b"blat")

def test_same_thing(self):

# gettempdir always returns the same object

a = tempfile.gettempdir()

b = tempfile.gettempdir()

c = tempfile.gettempdirb()

self.assertTrue(a is b)

self.assertNotEqual(type(a), type(c))

self.assertEqual(a, os.fsdecode(c))

def test_case_sensitive(self):

# gettempdir should not flatten its case

# even on a case-insensitive file system

case_sensitive_tempdir = tempfile.mkdtemp("-Temp")

_tempdir, tempfile.tempdir = tempfile.tempdir, None

try:

with os_helper.EnvironmentVarGuard() as env:

# Fake the first env var which is checked as a candidate

env["TMPDIR"] = case_sensitive_tempdir

self.assertEqual(tempfile.gettempdir(), case_sensitive_tempdir)

finally:

tempfile.tempdir = _tempdir

"""Test mkstemp()."""

def do_create(self, dir=None, pre=None, suf=None):

output_type = tempfile._infer_return_type(dir, pre, suf)

if dir is None:

if output_type is str:

dir = tempfile.gettempdir()

else:

dir = tempfile.gettempdirb()

if pre is None:

pre = output_type()

if suf is None:

suf = output_type()

(fd, name) = tempfile.mkstemp(dir=dir, prefix=pre, suffix=suf)

(ndir, nbase) = os.path.split(name)

adir = os.path.abspath(dir)

self.assertEqual(adir, ndir,

"Directory '%s' incorrectly returned as '%s'" % (adir, ndir))

try:

self.nameCheck(name, dir, pre, suf)

finally:

os.close(fd)

os.unlink(name)

def test_basic(self):

# mkstemp can create files

self.do_create()

self.do_create(pre="a")

self.do_create(suf="b")

self.do_create(pre="a", suf="b")

self.do_create(pre="aa", suf=".txt")

self.do_create(dir=".")

def test_basic_with_bytes_names(self):

# mkstemp can create files when given name parts all

# specified as bytes.

d = tempfile.gettempdirb()

self.do_create(dir=d, suf=b"")

self.do_create(dir=d, pre=b"a")

self.do_create(dir=d, suf=b"b")

self.do_create(dir=d, pre=b"a", suf=b"b")

self.do_create(dir=d, pre=b"aa", suf=b".txt")

self.do_create(dir=b".")

with self.assertRaises(TypeError):

self.do_create(dir=".", pre=b"aa", suf=b".txt")

with self.assertRaises(TypeError):

self.do_create(dir=b".", pre="aa", suf=b".txt")

with self.assertRaises(TypeError):

self.do_create(dir=b".", pre=b"aa", suf=".txt")

def test_choose_directory(self):

# mkstemp can create directories in a user-selected directory

dir = tempfile.mkdtemp()

try:

self.do_create(dir=dir)

self.do_create(dir=os_helper.FakePath(dir))

finally:

os.rmdir(dir)

def test_for_tempdir_is_bytes_issue40701_api_warts(self):

orig_tempdir = tempfile.tempdir

self.assertIsInstance(tempfile.tempdir, (str, type(None)))

try:

fd, path = tempfile.mkstemp()

os.close(fd)

os.unlink(path)

self.assertIsInstance(path, str)

tempfile.tempdir = tempfile.gettempdirb()

self.assertIsInstance(tempfile.tempdir, bytes)

self.assertIsInstance(tempfile.gettempdir(), str)

self.assertIsInstance(tempfile.gettempdirb(), bytes)

fd, path = tempfile.mkstemp()

os.close(fd)

os.unlink(path)

self.assertIsInstance(path, bytes)

fd, path = tempfile.mkstemp(suffix='.txt')

os.close(fd)

os.unlink(path)

self.assertIsInstance(path, str)

fd, path = tempfile.mkstemp(prefix='test-temp-')

os.close(fd)

os.unlink(path)

self.assertIsInstance(path, str)

fd, path = tempfile.mkstemp(dir=tempfile.gettempdir())

os.close(fd)

os.unlink(path)

self.assertIsInstance(path, str)

finally:

"""Test mkdtemp()."""

def make_temp(self):

return tempfile.mkdtemp()

def do_create(self, dir=None, pre=None, suf=None):

output_type = tempfile._infer_return_type(dir, pre, suf)

if dir is None:

if output_type is str:

dir = tempfile.gettempdir()

else:

dir = tempfile.gettempdirb()

if pre is None:

pre = output_type()

if suf is None:

suf = output_type()

name = tempfile.mkdtemp(dir=dir, prefix=pre, suffix=suf)

try:

self.nameCheck(name, dir, pre, suf)

return name

except:

os.rmdir(name)

raise

def test_basic(self):

# mkdtemp can create directories

os.rmdir(self.do_create())

os.rmdir(self.do_create(pre="a"))

os.rmdir(self.do_create(suf="b"))

os.rmdir(self.do_create(pre="a", suf="b"))

os.rmdir(self.do_create(pre="aa", suf=".txt"))

def test_basic_with_bytes_names(self):

# mkdtemp can create directories when given all binary parts

d = tempfile.gettempdirb()

os.rmdir(self.do_create(dir=d))

os.rmdir(self.do_create(dir=d, pre=b"a"))

os.rmdir(self.do_create(dir=d, suf=b"b"))

os.rmdir(self.do_create(dir=d, pre=b"a", suf=b"b"))

os.rmdir(self.do_create(dir=d, pre=b"aa", suf=b".txt"))

with self.assertRaises(TypeError):

os.rmdir(self.do_create(dir=d, pre="aa", suf=b".txt"))

with self.assertRaises(TypeError):

os.rmdir(self.do_create(dir=d, pre=b"aa", suf=".txt"))

with self.assertRaises(TypeError):

os.rmdir(self.do_create(dir="", pre=b"aa", suf=b".txt"))

def test_basic_many(self):

# mkdtemp can create many directories (stochastic)

extant = list(range(TEST_FILES))

try:

for i in extant:

extant[i] = self.do_create(pre="aa")

finally:

for i in extant:

if(isinstance(i, str)):

os.rmdir(i)

def test_choose_directory(self):

# mkdtemp can create directories in a user-selected directory

dir = tempfile.mkdtemp()

try:

os.rmdir(self.do_create(dir=dir))

os.rmdir(self.do_create(dir=os_helper.FakePath(dir)))

finally:

os.rmdir(dir)

@os_helper.skip_unless_working_chmod

def test_mode(self):

# mkdtemp creates directories with the proper mode

dir = self.do_create()

try:

mode = stat.S_IMODE(os.stat(dir).st_mode)

mode &= 0o777 # Mask off sticky bits inherited from /tmp

expected = 0o700

if sys.platform == 'win32':

# There's no distinction among 'user', 'group' and 'world';

# replicate the 'user' bits.

user = expected >> 6

expected = user * (1 + 8 + 64)

self.assertEqual(mode, expected)

finally:

os.rmdir(dir)

@unittest.skipUnless(os.name == "nt", "Only on Windows.")

def test_mode_win32(self):

# Use icacls.exe to extract the users with some level of access

# Main thing we are testing is that the BUILTIN\Users group has

# no access. The exact ACL is going to vary based on which user

# is running the test.

dir = self.do_create()

try:

out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()

finally:

os.rmdir(dir)

dir = dir.casefold()

users = set()

found_user = False

for line in out.strip().splitlines():

acl = None

# First line of result includes our directory

if line.startswith(dir):

acl = line.removeprefix(dir).strip()

elif line and line[:1].isspace():

acl = line.strip()

if acl:

users.add(acl.partition(":")[0])

self.assertNotIn(r"BUILTIN\Users".casefold(), users)

def test_collision_with_existing_file(self):

# mkdtemp tries another name when a file with

# the chosen name already exists

with _inside_empty_temp_dir(), \

_mock_candidate_names('aaa', 'aaa', 'bbb'):

file = tempfile.NamedTemporaryFile(delete=False)

file.close()

self.assertEndsWith(file.name, 'aaa')

dir = tempfile.mkdtemp()

self.assertEndsWith(dir, 'bbb')

def test_collision_with_existing_directory(self):

# mkdtemp tries another name when a directory with

# the chosen name already exists

with _inside_empty_temp_dir(), \

_mock_candidate_names('aaa', 'aaa', 'bbb'):

dir1 = tempfile.mkdtemp()

self.assertEndsWith(dir1, 'aaa')

dir2 = tempfile.mkdtemp()

self.assertEndsWith(dir2, 'bbb')

def test_for_tempdir_is_bytes_issue40701_api_warts(self):

orig_tempdir = tempfile.tempdir

self.assertIsInstance(tempfile.tempdir, (str, type(None)))

try:

path = tempfile.mkdtemp()

os.rmdir(path)

self.assertIsInstance(path, str)

tempfile.tempdir = tempfile.gettempdirb()

self.assertIsInstance(tempfile.tempdir, bytes)

self.assertIsInstance(tempfile.gettempdir(), str)

self.assertIsInstance(tempfile.gettempdirb(), bytes)

path = tempfile.mkdtemp()

os.rmdir(path)

self.assertIsInstance(path, bytes)

path = tempfile.mkdtemp(suffix='-dir')

os.rmdir(path)

self.assertIsInstance(path, str)

path = tempfile.mkdtemp(prefix='test-mkdtemp-')

os.rmdir(path)

self.assertIsInstance(path, str)

path = tempfile.mkdtemp(dir=tempfile.gettempdir())

os.rmdir(path)

self.assertIsInstance(path, str)

finally:

tempfile.tempdir = orig_tempdir

def test_path_is_absolute(self):

# Test that the path returned by mkdtemp with a relative `dir`

# argument is absolute

try:

path = tempfile.mkdtemp(dir=".")

self.assertTrue(os.path.isabs(path))

finally:

"""Test mktemp()."""

# For safety, all use of mktemp must occur in a private directory.

# We must also suppress the RuntimeWarning it generates.

def setUp(self):

self.dir = tempfile.mkdtemp()

super().setUp()

def tearDown(self):

if self.dir:

os.rmdir(self.dir)

self.dir = None

super().tearDown()

class mktemped:

_unlink = os.unlink

_bflags = tempfile._bin_openflags

def __init__(self, dir, pre, suf):

self.name = tempfile.mktemp(dir=dir, prefix=pre, suffix=suf)

# Create the file. This will raise an exception if it's

# mysteriously appeared in the meanwhile.

os.close(os.open(self.name, self._bflags, 0o600))

def __del__(self):

self._unlink(self.name)

def do_create(self, pre="", suf=""):

file = self.mktemped(self.dir, pre, suf)

self.nameCheck(file.name, self.dir, pre, suf)

return file

def test_basic(self):

# mktemp can choose usable file names

self.do_create()

self.do_create(pre="a")

self.do_create(suf="b")

self.do_create(pre="a", suf="b")

self.do_create(pre="aa", suf=".txt")

def test_many(self):

# mktemp can choose many usable file names (stochastic)

extant = list(range(TEST_FILES))

for i in extant:

extant[i] = self.do_create(pre="aa")

del extant

"""Test NamedTemporaryFile()."""

def do_create(self, dir=None, pre="", suf="", delete=True):

if dir is None:

dir = tempfile.gettempdir()

file = tempfile.NamedTemporaryFile(dir=dir, prefix=pre, suffix=suf,

delete=delete)

self.nameCheck(file.name, dir, pre, suf)

return file

def test_basic(self):

# NamedTemporaryFile can create files

f = self.do_create()

self.assertIsInstance(f, tempfile.TemporaryFileWrapper)

self.do_create(pre="a")

self.do_create(suf="b")

self.do_create(pre="a", suf="b")

self.do_create(pre="aa", suf=".txt")

def test_in_all(self):

self.assertIn("TemporaryFileWrapper", tempfile.__all__)

def test_deprecated_TemporaryFileWrapper_alias(self):

# gh-152586: _TemporaryFileWrapper is a deprecated alias

# for the public TemporaryFileWrapper class.

with self.assertWarns(DeprecationWarning):

obj = tempfile._TemporaryFileWrapper

self.assertIs(obj, tempfile.TemporaryFileWrapper)