Author: Armin Rigo <[email protected]>
Branch: py3.6-sandbox-2
Changeset: r97273:36a029317cc9
Date: 2019-08-26 17:21 +0200
http://bitbucket.org/pypy/pypy/changeset/36a029317cc9/
Log: merge 0d5f51e7a2c8
diff --git a/lib-python/3/_osx_support.py b/lib-python/3/_osx_support.py
deleted file mode 100644
--- a/lib-python/3/_osx_support.py
+++ /dev/null
@@ -1,504 +0,0 @@
-"""Shared OS X support functions."""
-
-import os
-import re
-import sys
-
-__all__ = [
- 'compiler_fixup',
- 'customize_config_vars',
- 'customize_compiler',
- 'get_platform_osx',
-]
-
-# configuration variables that may contain universal build flags,
-# like "-arch" or "-isdkroot", that may need customization for
-# the user environment
-_UNIVERSAL_CONFIG_VARS = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS', 'BASECFLAGS',
- 'BLDSHARED', 'LDSHARED', 'CC', 'CXX',
- 'PY_CFLAGS', 'PY_LDFLAGS', 'PY_CPPFLAGS',
- 'PY_CORE_CFLAGS', 'PY_CORE_LDFLAGS')
-
-# configuration variables that may contain compiler calls
-_COMPILER_CONFIG_VARS = ('BLDSHARED', 'LDSHARED', 'CC', 'CXX')
-
-# prefix added to original configuration variable names
-_INITPRE = '_OSX_SUPPORT_INITIAL_'
-
-
-def _find_executable(executable, path=None):
- """Tries to find 'executable' in the directories listed in 'path'.
-
- A string listing directories separated by 'os.pathsep'; defaults to
- os.environ['PATH']. Returns the complete filename or None if not found.
- """
- if path is None:
- path = os.environ['PATH']
-
- paths = path.split(os.pathsep)
- base, ext = os.path.splitext(executable)
-
- if (sys.platform == 'win32') and (ext != '.exe'):
- executable = executable + '.exe'
-
- if not os.path.isfile(executable):
- for p in paths:
- f = os.path.join(p, executable)
- if os.path.isfile(f):
- # the file exists, we have a shot at spawn working
- return f
- return None
- else:
- return executable
-
-
-def _read_output(commandstring):
- """Output from successful command execution or None"""
- # Similar to os.popen(commandstring, "r").read(),
- # but without actually using os.popen because that
- # function is not usable during python bootstrap.
- # tempfile is also not available then.
- import contextlib
- try:
- import tempfile
- fp = tempfile.NamedTemporaryFile()
- except ImportError:
- fp = open("/tmp/_osx_support.%s"%(
- os.getpid(),), "w+b")
-
- with contextlib.closing(fp) as fp:
- cmd = "%s 2>/dev/null >'%s'" % (commandstring, fp.name)
- return fp.read().decode('utf-8').strip() if not os.system(cmd) else
None
-
-
-def _find_build_tool(toolname):
- """Find a build tool on current path or using xcrun"""
- return (_find_executable(toolname)
- or _read_output("/usr/bin/xcrun -find %s" % (toolname,))
- or ''
- )
-
-_SYSTEM_VERSION = None
-
-def _get_system_version():
- """Return the OS X system version as a string"""
- # Reading this plist is a documented way to get the system
- # version (see the documentation for the Gestalt Manager)
- # We avoid using platform.mac_ver to avoid possible bootstrap issues during
- # the build of Python itself (distutils is used to build standard library
- # extensions).
-
- global _SYSTEM_VERSION
-
- if _SYSTEM_VERSION is None:
- _SYSTEM_VERSION = ''
- try:
- f = open('/System/Library/CoreServices/SystemVersion.plist')
- except OSError:
- # We're on a plain darwin box, fall back to the default
- # behaviour.
- pass
- else:
- try:
- m = re.search(r'<key>ProductUserVisibleVersion</key>\s*'
- r'<string>(.*?)</string>', f.read())
- finally:
- f.close()
- if m is not None:
- _SYSTEM_VERSION = '.'.join(m.group(1).split('.')[:2])
- # else: fall back to the default behaviour
- if not _SYSTEM_VERSION:
- # minimum supported MACOSX_DEPLOYMENT_TARGET version
- return '10.14'
- return _SYSTEM_VERSION
-
-def _remove_original_values(_config_vars):
- """Remove original unmodified values for testing"""
- # This is needed for higher-level cross-platform tests of get_platform.
- for k in list(_config_vars):
- if k.startswith(_INITPRE):
- del _config_vars[k]
-
-def _save_modified_value(_config_vars, cv, newvalue):
- """Save modified and original unmodified value of configuration var"""
-
- oldvalue = _config_vars.get(cv, '')
- if (oldvalue != newvalue) and (_INITPRE + cv not in _config_vars):
- _config_vars[_INITPRE + cv] = oldvalue
- _config_vars[cv] = newvalue
-
-def _supports_universal_builds():
- """Returns True if universal builds are supported on this system"""
- # As an approximation, we assume that if we are running on 10.4 or above,
- # then we are running with an Xcode environment that supports universal
- # builds, in particular -isysroot and -arch arguments to the compiler. This
- # is in support of allowing 10.4 universal builds to run on 10.3.x systems.
-
- osx_version = _get_system_version()
- if osx_version:
- try:
- osx_version = tuple(int(i) for i in osx_version.split('.'))
- except ValueError:
- osx_version = ''
- return bool(osx_version >= (10, 4)) if osx_version else False
-
-
-def _find_appropriate_compiler(_config_vars):
- """Find appropriate C compiler for extension module builds"""
-
- # Issue #13590:
- # The OSX location for the compiler varies between OSX
- # (or rather Xcode) releases. With older releases (up-to 10.5)
- # the compiler is in /usr/bin, with newer releases the compiler
- # can only be found inside Xcode.app if the "Command Line Tools"
- # are not installed.
- #
- # Furthermore, the compiler that can be used varies between
- # Xcode releases. Up to Xcode 4 it was possible to use 'gcc-4.2'
- # as the compiler, after that 'clang' should be used because
- # gcc-4.2 is either not present, or a copy of 'llvm-gcc' that
- # miscompiles Python.
-
- # skip checks if the compiler was overridden with a CC env variable
- if 'CC' in os.environ:
- return _config_vars
-
- # The CC config var might contain additional arguments.
- # Ignore them while searching.
- cc = oldcc = _config_vars['CC'].split()[0]
- if not _find_executable(cc):
- # Compiler is not found on the shell search PATH.
- # Now search for clang, first on PATH (if the Command LIne
- # Tools have been installed in / or if the user has provided
- # another location via CC). If not found, try using xcrun
- # to find an uninstalled clang (within a selected Xcode).
-
- # NOTE: Cannot use subprocess here because of bootstrap
- # issues when building Python itself (and os.popen is
- # implemented on top of subprocess and is therefore not
- # usable as well)
-
- cc = _find_build_tool('clang')
-
- elif os.path.basename(cc).startswith('gcc'):
- # Compiler is GCC, check if it is LLVM-GCC
- data = _read_output("'%s' --version"
- % (cc.replace("'", "'\"'\"'"),))
- if data and 'llvm-gcc' in data:
- # Found LLVM-GCC, fall back to clang
- cc = _find_build_tool('clang')
-
- if not cc:
- raise SystemError(
- "Cannot locate working compiler")
-
- if cc != oldcc:
- # Found a replacement compiler.
- # Modify config vars using new compiler, if not already explicitly
- # overridden by an env variable, preserving additional arguments.
- for cv in _COMPILER_CONFIG_VARS:
- if cv in _config_vars and cv not in os.environ:
- cv_split = _config_vars[cv].split()
- cv_split[0] = cc if cv != 'CXX' else cc + '++'
- _save_modified_value(_config_vars, cv, ' '.join(cv_split))
-
- return _config_vars
-
-
-def _remove_universal_flags(_config_vars):
- """Remove all universal build arguments from config vars"""
-
- for cv in _UNIVERSAL_CONFIG_VARS:
- # Do not alter a config var explicitly overridden by env var
- if cv in _config_vars and cv not in os.environ:
- flags = _config_vars[cv]
- flags = re.sub(r'-arch\s+\w+\s', ' ', flags, flags=re.ASCII)
- flags = re.sub('-isysroot [^ \t]*', ' ', flags)
- _save_modified_value(_config_vars, cv, flags)
-
- return _config_vars
-
-
-def _remove_unsupported_archs(_config_vars):
- """Remove any unsupported archs from config vars"""
- # Different Xcode releases support different sets for '-arch'
- # flags. In particular, Xcode 4.x no longer supports the
- # PPC architectures.
- #
- # This code automatically removes '-arch ppc' and '-arch ppc64'
- # when these are not supported. That makes it possible to
- # build extensions on OSX 10.7 and later with the prebuilt
- # 32-bit installer on the python.org website.
-
- # skip checks if the compiler was overridden with a CC env variable
- if 'CC' in os.environ:
- return _config_vars
-
- if re.search(r'-arch\s+ppc', _config_vars['CFLAGS']) is not None:
- # NOTE: Cannot use subprocess here because of bootstrap
- # issues when building Python itself
- status = os.system(
- """echo 'int main{};' | """
- """'%s' -c -arch ppc -x c -o /dev/null /dev/null 2>/dev/null"""
- %(_config_vars['CC'].replace("'", "'\"'\"'"),))
- if status:
- # The compile failed for some reason. Because of differences
- # across Xcode and compiler versions, there is no reliable way
- # to be sure why it failed. Assume here it was due to lack of
- # PPC support and remove the related '-arch' flags from each
- # config variables not explicitly overridden by an environment
- # variable. If the error was for some other reason, we hope the
- # failure will show up again when trying to compile an extension
- # module.
- for cv in _UNIVERSAL_CONFIG_VARS:
- if cv in _config_vars and cv not in os.environ:
- flags = _config_vars[cv]
- flags = re.sub(r'-arch\s+ppc\w*\s', ' ', flags)
- _save_modified_value(_config_vars, cv, flags)
-
- return _config_vars
-
-
-def _override_all_archs(_config_vars):
- """Allow override of all archs with ARCHFLAGS env var"""
- # NOTE: This name was introduced by Apple in OSX 10.5 and
- # is used by several scripting languages distributed with
- # that OS release.
- if 'ARCHFLAGS' in os.environ:
- arch = os.environ['ARCHFLAGS']
- for cv in _UNIVERSAL_CONFIG_VARS:
- if cv in _config_vars and '-arch' in _config_vars[cv]:
- flags = _config_vars[cv]
- flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
- flags = flags + ' ' + arch
- _save_modified_value(_config_vars, cv, flags)
-
- return _config_vars
-
-
-def _check_for_unavailable_sdk(_config_vars):
- """Remove references to any SDKs not available"""
- # If we're on OSX 10.5 or later and the user tries to
- # compile an extension using an SDK that is not present
- # on the current machine it is better to not use an SDK
- # than to fail. This is particularly important with
- # the standalone Command Line Tools alternative to a
- # full-blown Xcode install since the CLT packages do not
- # provide SDKs. If the SDK is not present, it is assumed
- # that the header files and dev libs have been installed
- # to /usr and /System/Library by either a standalone CLT
- # package or the CLT component within Xcode.
- cflags = _config_vars.get('CFLAGS', '')
- m = re.search(r'-isysroot\s+(\S+)', cflags)
- if m is not None:
- sdk = m.group(1)
- if not os.path.exists(sdk):
- for cv in _UNIVERSAL_CONFIG_VARS:
- # Do not alter a config var explicitly overridden by env var
- if cv in _config_vars and cv not in os.environ:
- flags = _config_vars[cv]
- flags = re.sub(r'-isysroot\s+\S+(?:\s|$)', ' ', flags)
- _save_modified_value(_config_vars, cv, flags)
-
- return _config_vars
-
-
-def compiler_fixup(compiler_so, cc_args):
- """
- This function will strip '-isysroot PATH' and '-arch ARCH' from the
- compile flags if the user has specified one them in extra_compile_flags.
-
- This is needed because '-arch ARCH' adds another architecture to the
- build, without a way to remove an architecture. Furthermore GCC will
- barf if multiple '-isysroot' arguments are present.
- """
- stripArch = stripSysroot = False
-
- compiler_so = list(compiler_so)
-
- if not _supports_universal_builds():
- # OSX before 10.4.0, these don't support -arch and -isysroot at
- # all.
- stripArch = stripSysroot = True
- else:
- stripArch = '-arch' in cc_args
- stripSysroot = '-isysroot' in cc_args
-
- if stripArch or 'ARCHFLAGS' in os.environ:
- while True:
- try:
- index = compiler_so.index('-arch')
- # Strip this argument and the next one:
- del compiler_so[index:index+2]
- except ValueError:
- break
-
- if 'ARCHFLAGS' in os.environ and not stripArch:
- # User specified different -arch flags in the environ,
- # see also distutils.sysconfig
- compiler_so = compiler_so + os.environ['ARCHFLAGS'].split()
-
- if stripSysroot:
- while True:
- try:
- index = compiler_so.index('-isysroot')
- # Strip this argument and the next one:
- del compiler_so[index:index+2]
- except ValueError:
- break
-
- # Check if the SDK that is used during compilation actually exists,
- # the universal build requires the usage of a universal SDK and not all
- # users have that installed by default.
- sysroot = None
- if '-isysroot' in cc_args:
- idx = cc_args.index('-isysroot')
- sysroot = cc_args[idx+1]
- elif '-isysroot' in compiler_so:
- idx = compiler_so.index('-isysroot')
- sysroot = compiler_so[idx+1]
-
- if sysroot and not os.path.isdir(sysroot):
- from distutils import log
- log.warn("Compiling with an SDK that doesn't seem to exist: %s",
- sysroot)
- log.warn("Please check your Xcode installation")
-
- return compiler_so
-
-
-def customize_config_vars(_config_vars):
- """Customize Python build configuration variables.
-
- Called internally from sysconfig with a mutable mapping
- containing name/value pairs parsed from the configured
- makefile used to build this interpreter. Returns
- the mapping updated as needed to reflect the environment
- in which the interpreter is running; in the case of
- a Python from a binary installer, the installed
- environment may be very different from the build
- environment, i.e. different OS levels, different
- built tools, different available CPU architectures.
-
- This customization is performed whenever
- distutils.sysconfig.get_config_vars() is first
- called. It may be used in environments where no
- compilers are present, i.e. when installing pure
- Python dists. Customization of compiler paths
- and detection of unavailable archs is deferred
- until the first extension module build is
- requested (in distutils.sysconfig.customize_compiler).
-
- Currently called from distutils.sysconfig
- """
-
- if not _supports_universal_builds():
- # On Mac OS X before 10.4, check if -arch and -isysroot
- # are in CFLAGS or LDFLAGS and remove them if they are.
- # This is needed when building extensions on a 10.3 system
- # using a universal build of python.
- _remove_universal_flags(_config_vars)
-
- # Allow user to override all archs with ARCHFLAGS env var
- _override_all_archs(_config_vars)
-
- # Remove references to sdks that are not found
- _check_for_unavailable_sdk(_config_vars)
-
- return _config_vars
-
-
-def customize_compiler(_config_vars):
- """Customize compiler path and configuration variables.
-
- This customization is performed when the first
- extension module build is requested
- in distutils.sysconfig.customize_compiler).
- """
-
- # Find a compiler to use for extension module builds
- _find_appropriate_compiler(_config_vars)
-
- # Remove ppc arch flags if not supported here
- _remove_unsupported_archs(_config_vars)
-
- # Allow user to override all archs with ARCHFLAGS env var
- _override_all_archs(_config_vars)
-
- return _config_vars
-
-
-def get_platform_osx(_config_vars, osname, release, machine):
- """Filter values for get_platform()"""
- # called from get_platform() in sysconfig and distutils.util
- #
- # For our purposes, we'll assume that the system version from
- # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
- # to. This makes the compatibility story a bit more sane because the
- # machine is going to compile and link as if it were
- # MACOSX_DEPLOYMENT_TARGET.
-
- macver = _config_vars.get('MACOSX_DEPLOYMENT_TARGET', '')
- macrelease = _get_system_version() or macver
- macver = macver or macrelease
-
- if macver:
- release = macver
- osname = "macosx"
-
- # Use the original CFLAGS value, if available, so that we
- # return the same machine type for the platform string.
- # Otherwise, distutils may consider this a cross-compiling
- # case and disallow installs.
- cflags = _config_vars.get(_INITPRE+'CFLAGS',
- _config_vars.get('CFLAGS', ''))
- if macrelease:
- try:
- macrelease = tuple(int(i) for i in macrelease.split('.')[0:2])
- except ValueError:
- macrelease = (10, 0)
- else:
- # assume no universal support
- macrelease = (10, 0)
-
- if (macrelease >= (10, 4)) and '-arch' in cflags.strip():
- # The universal build will build fat binaries, but not on
- # systems before 10.4
-
- machine = 'fat'
-
- archs = re.findall(r'-arch\s+(\S+)', cflags)
- archs = tuple(sorted(set(archs)))
-
- if len(archs) == 1:
- machine = archs[0]
- elif archs == ('i386', 'ppc'):
- machine = 'fat'
- elif archs == ('i386', 'x86_64'):
- machine = 'intel'
- elif archs == ('i386', 'ppc', 'x86_64'):
- machine = 'fat3'
- elif archs == ('ppc64', 'x86_64'):
- machine = 'fat64'
- elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
- machine = 'universal'
- else:
- raise ValueError(
- "Don't know machine value for archs=%r" % (archs,))
-
- elif machine == 'i386':
- # On OSX the machine type returned by uname is always the
- # 32-bit variant, even if the executable architecture is
- # the 64-bit variant
- if sys.maxsize >= 2**32:
- machine = 'x86_64'
-
- elif machine in ('PowerPC', 'Power_Macintosh'):
- # Pick a sane name for the PPC architecture.
- # See 'i386' case
- if sys.maxsize >= 2**32:
- machine = 'ppc64'
- else:
- machine = 'ppc'
-
- return (osname, release, machine)
diff --git a/lib-python/3/test/crashers/trace_at_recursion_limit.py
b/lib-python/3/test/crashers/trace_at_recursion_limit.py
deleted file mode 100644
--- a/lib-python/3/test/crashers/trace_at_recursion_limit.py
+++ /dev/null
@@ -1,27 +0,0 @@
-"""
-From http://bugs.python.org/issue6717
-
-A misbehaving trace hook can trigger a segfault by exceeding the recursion
-limit.
-"""
-import sys
-
-
-def x():
- pass
-
-def g(*args):
- if True: # change to True to crash interpreter
- try:
- x()
- except:
- pass
- return g
-
-def f():
- print(sys.getrecursionlimit())
- f()
-
-sys.settrace(g)
-
-f()
diff --git a/lib-python/3/test/json_tests/test_tool.py
b/lib-python/3/test/json_tests/test_tool.py
deleted file mode 100644
--- a/lib-python/3/test/json_tests/test_tool.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import os
-import sys
-import textwrap
-import unittest
-import subprocess
-from test import support
-from test.script_helper import assert_python_ok
-
-class TestTool(unittest.TestCase):
- data = """
-
- [["blorpie"],[ "whoops" ] , [
- ],\t"d-shtaeou",\r"d-nthiouh",
- "i-vhbjkhnth", {"nifty":87}, {"morefield" :\tfalse,"field"
- :"yes"} ]
- """
-
- expect = textwrap.dedent("""\
- [
- [
- "blorpie"
- ],
- [
- "whoops"
- ],
- [],
- "d-shtaeou",
- "d-nthiouh",
- "i-vhbjkhnth",
- {
- "nifty": 87
- },
- {
- "field": "yes",
- "morefield": false
- }
- ]
- """)
-
- def test_stdin_stdout(self):
- with subprocess.Popen(
- (sys.executable, '-m', 'json.tool'),
- stdin=subprocess.PIPE, stdout=subprocess.PIPE) as proc:
- out, err = proc.communicate(self.data.encode())
- self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
- self.assertEqual(err, None)
-
- def _create_infile(self):
- infile = support.TESTFN
- with open(infile, "w") as fp:
- self.addCleanup(os.remove, infile)
- fp.write(self.data)
- return infile
-
- def test_infile_stdout(self):
- infile = self._create_infile()
- rc, out, err = assert_python_ok('-m', 'json.tool', infile)
- self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
- self.assertEqual(err, b'')
-
- def test_infile_outfile(self):
- infile = self._create_infile()
- outfile = support.TESTFN + '.out'
- rc, out, err = assert_python_ok('-m', 'json.tool', infile, outfile)
- self.addCleanup(os.remove, outfile)
- with open(outfile, "r") as fp:
- self.assertEqual(fp.read(), self.expect)
- self.assertEqual(out, b'')
- self.assertEqual(err, b'')
diff --git a/lib-python/3/test/mp_fork_bomb.py
b/lib-python/3/test/mp_fork_bomb.py
deleted file mode 100644
--- a/lib-python/3/test/mp_fork_bomb.py
+++ /dev/null
@@ -1,18 +0,0 @@
-import multiprocessing, sys
-
-def foo():
- print("123")
-
-# Because "if __name__ == '__main__'" is missing this will not work
-# correctly on Windows. However, we should get a RuntimeError rather
-# than the Windows equivalent of a fork bomb.
-
-if len(sys.argv) > 1:
- multiprocessing.set_start_method(sys.argv[1])
-else:
- multiprocessing.set_start_method('spawn')
-
-p = multiprocessing.Process(target=foo)
-p.start()
-p.join()
-sys.exit(p.exitcode)
diff --git a/lib-python/3/test/sample_doctest_no_docstrings.py
b/lib-python/3/test/sample_doctest_no_docstrings.py
deleted file mode 100644
--- a/lib-python/3/test/sample_doctest_no_docstrings.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# This is a sample module used for testing doctest.
-#
-# This module is for testing how doctest handles a module with no
-# docstrings.
-
-
-class Foo(object):
-
- # A class with no docstring.
-
- def __init__(self):
- pass
diff --git a/lib-python/3/test/sample_doctest_no_doctests.py
b/lib-python/3/test/sample_doctest_no_doctests.py
deleted file mode 100644
--- a/lib-python/3/test/sample_doctest_no_doctests.py
+++ /dev/null
@@ -1,15 +0,0 @@
-"""This is a sample module used for testing doctest.
-
-This module is for testing how doctest handles a module with docstrings
-but no doctest examples.
-
-"""
-
-
-class Foo(object):
- """A docstring with no doctest examples.
-
- """
-
- def __init__(self):
- pass
diff --git a/lib-python/3/test/test__osx_support.py
b/lib-python/3/test/test__osx_support.py
deleted file mode 100644
--- a/lib-python/3/test/test__osx_support.py
+++ /dev/null
@@ -1,276 +0,0 @@
-"""
-Test suite for _osx_support: shared OS X support functions.
-"""
-
-import os
-import platform
-import stat
-import sys
-import unittest
-
-import test.support
-
-import _osx_support
-
[email protected](sys.platform.startswith("darwin"), "requires OS X")
-class Test_OSXSupport(unittest.TestCase):
-
- def setUp(self):
- self.maxDiff = None
- self.prog_name = 'bogus_program_xxxx'
- self.temp_path_dir = os.path.abspath(os.getcwd())
- self.env = test.support.EnvironmentVarGuard()
- self.addCleanup(self.env.__exit__)
- for cv in ('CFLAGS', 'LDFLAGS', 'CPPFLAGS',
- 'BASECFLAGS', 'BLDSHARED', 'LDSHARED', 'CC',
- 'CXX', 'PY_CFLAGS', 'PY_LDFLAGS', 'PY_CPPFLAGS',
- 'PY_CORE_CFLAGS', 'PY_CORE_LDFLAGS'):
- if cv in self.env:
- self.env.unset(cv)
-
- def add_expected_saved_initial_values(self, config_vars, expected_vars):
- # Ensure that the initial values for all modified config vars
- # are also saved with modified keys.
- expected_vars.update(('_OSX_SUPPORT_INITIAL_'+ k,
- config_vars[k]) for k in config_vars
- if config_vars[k] != expected_vars[k])
-
- def test__find_executable(self):
- if self.env['PATH']:
- self.env['PATH'] = self.env['PATH'] + ':'
- self.env['PATH'] = self.env['PATH'] +
os.path.abspath(self.temp_path_dir)
- test.support.unlink(self.prog_name)
- self.assertIsNone(_osx_support._find_executable(self.prog_name))
- self.addCleanup(test.support.unlink, self.prog_name)
- with open(self.prog_name, 'w') as f:
- f.write("#!/bin/sh\n/bin/echo OK\n")
- os.chmod(self.prog_name, stat.S_IRWXU)
- self.assertEqual(self.prog_name,
- _osx_support._find_executable(self.prog_name))
-
- def test__read_output(self):
- if self.env['PATH']:
- self.env['PATH'] = self.env['PATH'] + ':'
- self.env['PATH'] = self.env['PATH'] +
os.path.abspath(self.temp_path_dir)
- test.support.unlink(self.prog_name)
- self.addCleanup(test.support.unlink, self.prog_name)
- with open(self.prog_name, 'w') as f:
- f.write("#!/bin/sh\n/bin/echo ExpectedOutput\n")
- os.chmod(self.prog_name, stat.S_IRWXU)
- self.assertEqual('ExpectedOutput',
- _osx_support._read_output(self.prog_name))
-
- def test__find_build_tool(self):
- out = _osx_support._find_build_tool('cc')
- self.assertTrue(os.path.isfile(out),
- 'cc not found - check xcode-select')
-
- def test__get_system_version(self):
- self.assertTrue(platform.mac_ver()[0].startswith(
- _osx_support._get_system_version()))
-
- def test__remove_original_values(self):
- config_vars = {
- 'CC': 'gcc-test -pthreads',
- }
- expected_vars = {
- 'CC': 'clang -pthreads',
- }
- cv = 'CC'
- newvalue = 'clang -pthreads'
- _osx_support._save_modified_value(config_vars, cv, newvalue)
- self.assertNotEqual(expected_vars, config_vars)
- _osx_support._remove_original_values(config_vars)
- self.assertEqual(expected_vars, config_vars)
-
- def test__save_modified_value(self):
- config_vars = {
- 'CC': 'gcc-test -pthreads',
- }
- expected_vars = {
- 'CC': 'clang -pthreads',
- }
- self.add_expected_saved_initial_values(config_vars, expected_vars)
- cv = 'CC'
- newvalue = 'clang -pthreads'
- _osx_support._save_modified_value(config_vars, cv, newvalue)
- self.assertEqual(expected_vars, config_vars)
-
- def test__save_modified_value_unchanged(self):
- config_vars = {
- 'CC': 'gcc-test -pthreads',
- }
- expected_vars = config_vars.copy()
- cv = 'CC'
- newvalue = 'gcc-test -pthreads'
- _osx_support._save_modified_value(config_vars, cv, newvalue)
- self.assertEqual(expected_vars, config_vars)
-
- def test__supports_universal_builds(self):
- import platform
- mac_ver_tuple = tuple(int(i) for i in
- platform.mac_ver()[0].split('.')[0:2])
- self.assertEqual(mac_ver_tuple >= (10, 4),
- _osx_support._supports_universal_builds())
-
- def test__find_appropriate_compiler(self):
- compilers = (
- ('gcc-test', 'i686-apple-darwin11-llvm-gcc-4.2'),
- ('clang', 'clang version 3.1'),
- )
- config_vars = {
- 'CC': 'gcc-test -pthreads',
- 'CXX': 'cc++-test',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 ',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'gcc-test -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'gcc-test -bundle -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.4u.sdk -g',
- }
- expected_vars = {
- 'CC': 'clang -pthreads',
- 'CXX': 'clang++',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 ',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'clang -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'clang -bundle -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.4u.sdk -g',
- }
- self.add_expected_saved_initial_values(config_vars, expected_vars)
-
- suffix = (':' + self.env['PATH']) if self.env['PATH'] else ''
- self.env['PATH'] = os.path.abspath(self.temp_path_dir) + suffix
- for c_name, c_output in compilers:
- test.support.unlink(c_name)
- self.addCleanup(test.support.unlink, c_name)
- with open(c_name, 'w') as f:
- f.write("#!/bin/sh\n/bin/echo " + c_output)
- os.chmod(c_name, stat.S_IRWXU)
- self.assertEqual(expected_vars,
- _osx_support._find_appropriate_compiler(
- config_vars))
-
- def test__remove_universal_flags(self):
- config_vars = {
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 ',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.4u.sdk -g',
- }
- expected_vars = {
- 'CFLAGS': '-fno-strict-aliasing -g -O3 ',
- 'LDFLAGS': ' -g',
- 'CPPFLAGS': '-I. ',
- 'BLDSHARED': 'gcc-4.0 -bundle -g',
- 'LDSHARED': 'gcc-4.0 -bundle -g',
- }
- self.add_expected_saved_initial_values(config_vars, expected_vars)
-
- self.assertEqual(expected_vars,
- _osx_support._remove_universal_flags(
- config_vars))
-
- def test__remove_unsupported_archs(self):
- config_vars = {
- 'CC': 'clang',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 ',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.4u.sdk -g',
- }
- expected_vars = {
- 'CC': 'clang',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch i386 ',
- 'LDFLAGS': ' -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'gcc-4.0 -bundle -arch i386 -g',
- 'LDSHARED': 'gcc-4.0 -bundle -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.4u.sdk -g',
- }
- self.add_expected_saved_initial_values(config_vars, expected_vars)
-
- suffix = (':' + self.env['PATH']) if self.env['PATH'] else ''
- self.env['PATH'] = os.path.abspath(self.temp_path_dir) + suffix
- c_name = 'clang'
- test.support.unlink(c_name)
- self.addCleanup(test.support.unlink, c_name)
- # exit status 255 means no PPC support in this compiler chain
- with open(c_name, 'w') as f:
- f.write("#!/bin/sh\nexit 255")
- os.chmod(c_name, stat.S_IRWXU)
- self.assertEqual(expected_vars,
- _osx_support._remove_unsupported_archs(
- config_vars))
-
- def test__override_all_archs(self):
- self.env['ARCHFLAGS'] = '-arch x86_64'
- config_vars = {
- 'CC': 'clang',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 ',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.4u.sdk -g',
- }
- expected_vars = {
- 'CC': 'clang',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch x86_64',
- 'LDFLAGS': ' -g -arch x86_64',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.4u.sdk',
- 'BLDSHARED': 'gcc-4.0 -bundle -g -arch x86_64',
- 'LDSHARED': 'gcc-4.0 -bundle -isysroot '
- '/Developer/SDKs/MacOSX10.4u.sdk -g -arch x86_64',
- }
- self.add_expected_saved_initial_values(config_vars, expected_vars)
-
- self.assertEqual(expected_vars,
- _osx_support._override_all_archs(
- config_vars))
-
- def test__check_for_unavailable_sdk(self):
- config_vars = {
- 'CC': 'clang',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.1.sdk',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. -isysroot /Developer/SDKs/MacOSX10.1.sdk',
- 'BLDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.1.sdk -g',
- }
- expected_vars = {
- 'CC': 'clang',
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 '
- ' ',
- 'LDFLAGS': '-arch ppc -arch i386 -g',
- 'CPPFLAGS': '-I. ',
- 'BLDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 -g',
- 'LDSHARED': 'gcc-4.0 -bundle -arch ppc -arch i386 '
- ' -g',
- }
- self.add_expected_saved_initial_values(config_vars, expected_vars)
-
- self.assertEqual(expected_vars,
- _osx_support._check_for_unavailable_sdk(
- config_vars))
-
- def test_get_platform_osx(self):
- # Note, get_platform_osx is currently tested more extensively
- # indirectly by test_sysconfig and test_distutils
- config_vars = {
- 'CFLAGS': '-fno-strict-aliasing -g -O3 -arch ppc -arch i386 '
- '-isysroot /Developer/SDKs/MacOSX10.1.sdk',
- 'MACOSX_DEPLOYMENT_TARGET': '10.6',
- }
- result = _osx_support.get_platform_osx(config_vars, ' ', ' ', ' ')
- self.assertEqual(('macosx', '10.6', 'fat'), result)
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/lib-python/3/test/test_file_eintr.py
b/lib-python/3/test/test_file_eintr.py
deleted file mode 100644
--- a/lib-python/3/test/test_file_eintr.py
+++ /dev/null
@@ -1,252 +0,0 @@
-# Written to test interrupted system calls interfering with our many buffered
-# IO implementations. http://bugs.python.org/issue12268
-#
-# It was suggested that this code could be merged into test_io and the tests
-# made to work using the same method as the existing signal tests in test_io.
-# I was unable to get single process tests using alarm or setitimer that way
-# to reproduce the EINTR problems. This process based test suite reproduces
-# the problems prior to the issue12268 patch reliably on Linux and OSX.
-# - gregory.p.smith
-
-import os
-import select
-import signal
-import subprocess
-import sys
-import time
-import unittest
-
-# Test import all of the things we're about to try testing up front.
-import _io
-import _pyio
-
-
[email protected](os.name == 'posix', 'tests requires a posix system.')
-class TestFileIOSignalInterrupt:
- def setUp(self):
- self._process = None
-
- def tearDown(self):
- if self._process and self._process.poll() is None:
- try:
- self._process.kill()
- except OSError:
- pass
-
- def _generate_infile_setup_code(self):
- """Returns the infile = ... line of code for the reader process.
-
- subclasseses should override this to test different IO objects.
- """
- return ('import %s as io ;'
- 'infile = io.FileIO(sys.stdin.fileno(), "rb")' %
- self.modname)
-
- def fail_with_process_info(self, why, stdout=b'', stderr=b'',
- communicate=True):
- """A common way to cleanup and fail with useful debug output.
-
- Kills the process if it is still running, collects remaining output
- and fails the test with an error message including the output.
-
- Args:
- why: Text to go after "Error from IO process" in the message.
- stdout, stderr: standard output and error from the process so
- far to include in the error message.
- communicate: bool, when True we call communicate() on the process
- after killing it to gather additional output.
- """
- if self._process.poll() is None:
- time.sleep(0.1) # give it time to finish printing the error.
- try:
- self._process.terminate() # Ensure it dies.
- except OSError:
- pass
- if communicate:
- stdout_end, stderr_end = self._process.communicate()
- stdout += stdout_end
- stderr += stderr_end
- self.fail('Error from IO process %s:\nSTDOUT:\n%sSTDERR:\n%s\n' %
- (why, stdout.decode(), stderr.decode()))
-
- def _test_reading(self, data_to_write, read_and_verify_code):
- """Generic buffered read method test harness to validate EINTR
behavior.
-
- Also validates that Python signal handlers are run during the read.
-
- Args:
- data_to_write: String to write to the child process for reading
- before sending it a signal, confirming the signal was handled,
- writing a final newline and closing the infile pipe.
- read_and_verify_code: Single "line" of code to read from a file
- object named 'infile' and validate the result. This will be
- executed as part of a python subprocess fed data_to_write.
- """
- infile_setup_code = self._generate_infile_setup_code()
- # Total pipe IO in this function is smaller than the minimum posix OS
- # pipe buffer size of 512 bytes. No writer should block.
- assert len(data_to_write) < 512, 'data_to_write must fit in pipe buf.'
-
- # Start a subprocess to call our read method while handling a signal.
- self._process = subprocess.Popen(
- [sys.executable, '-u', '-c',
- 'import signal, sys ;'
- 'signal.signal(signal.SIGINT, '
- 'lambda s, f: sys.stderr.write("$\\n")) ;'
- + infile_setup_code + ' ;' +
- 'sys.stderr.write("Worm Sign!\\n") ;'
- + read_and_verify_code + ' ;' +
- 'infile.close()'
- ],
- stdin=subprocess.PIPE, stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
-
- # Wait for the signal handler to be installed.
- worm_sign = self._process.stderr.read(len(b'Worm Sign!\n'))
- if worm_sign != b'Worm Sign!\n': # See also, Dune by Frank Herbert.
- self.fail_with_process_info('while awaiting a sign',
- stderr=worm_sign)
- self._process.stdin.write(data_to_write)
-
- signals_sent = 0
- rlist = []
- # We don't know when the read_and_verify_code in our child is actually
- # executing within the read system call we want to interrupt. This
- # loop waits for a bit before sending the first signal to increase
- # the likelihood of that. Implementations without correct EINTR
- # and signal handling usually fail this test.
- while not rlist:
- rlist, _, _ = select.select([self._process.stderr], (), (), 0.05)
- self._process.send_signal(signal.SIGINT)
- signals_sent += 1
- if signals_sent > 200:
- self._process.kill()
- self.fail('reader process failed to handle our signals.')
- # This assumes anything unexpected that writes to stderr will also
- # write a newline. That is true of the traceback printing code.
- signal_line = self._process.stderr.readline()
- if signal_line != b'$\n':
- self.fail_with_process_info('while awaiting signal',
- stderr=signal_line)
-
- # We append a newline to our input so that a readline call can
- # end on its own before the EOF is seen and so that we're testing
- # the read call that was interrupted by a signal before the end of
- # the data stream has been reached.
- stdout, stderr = self._process.communicate(input=b'\n')
- if self._process.returncode:
- self.fail_with_process_info(
- 'exited rc=%d' % self._process.returncode,
- stdout, stderr, communicate=False)
- # PASS!
-
- # String format for the read_and_verify_code used by read methods.
- _READING_CODE_TEMPLATE = (
- 'got = infile.{read_method_name}() ;'
- 'expected = {expected!r} ;'
- 'assert got == expected, ('
- '"{read_method_name} returned wrong data.\\n"'
- '"got data %r\\nexpected %r" % (got, expected))'
- )
-
- def test_readline(self):
- """readline() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello, world!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='readline',
- expected=b'hello, world!\n'))
-
- def test_readlines(self):
- """readlines() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello\nworld!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='readlines',
- expected=[b'hello\n', b'world!\n']))
-
- def test_readall(self):
- """readall() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello\nworld!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='readall',
- expected=b'hello\nworld!\n'))
- # read() is the same thing as readall().
- self._test_reading(
- data_to_write=b'hello\nworld!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='read',
- expected=b'hello\nworld!\n'))
-
-
-class CTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
- modname = '_io'
-
-class PyTestFileIOSignalInterrupt(TestFileIOSignalInterrupt,
unittest.TestCase):
- modname = '_pyio'
-
-
-class TestBufferedIOSignalInterrupt(TestFileIOSignalInterrupt):
- def _generate_infile_setup_code(self):
- """Returns the infile = ... line of code to make a BufferedReader."""
- return ('import %s as io ;infile = io.open(sys.stdin.fileno(), "rb") ;'
- 'assert isinstance(infile, io.BufferedReader)' %
- self.modname)
-
- def test_readall(self):
- """BufferedReader.read() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello\nworld!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='read',
- expected=b'hello\nworld!\n'))
-
-class CTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt,
unittest.TestCase):
- modname = '_io'
-
-class PyTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt,
unittest.TestCase):
- modname = '_pyio'
-
-
-class TestTextIOSignalInterrupt(TestFileIOSignalInterrupt):
- def _generate_infile_setup_code(self):
- """Returns the infile = ... line of code to make a TextIOWrapper."""
- return ('import %s as io ;'
- 'infile = io.open(sys.stdin.fileno(), "rt", newline=None) ;'
- 'assert isinstance(infile, io.TextIOWrapper)' %
- self.modname)
-
- def test_readline(self):
- """readline() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello, world!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='readline',
- expected='hello, world!\n'))
-
- def test_readlines(self):
- """readlines() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello\r\nworld!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='readlines',
- expected=['hello\n', 'world!\n']))
-
- def test_readall(self):
- """read() must handle signals and not lose data."""
- self._test_reading(
- data_to_write=b'hello\nworld!',
- read_and_verify_code=self._READING_CODE_TEMPLATE.format(
- read_method_name='read',
- expected="hello\nworld!\n"))
-
-class CTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
- modname = '_io'
-
-class PyTestTextIOSignalInterrupt(TestTextIOSignalInterrupt,
unittest.TestCase):
- modname = '_pyio'
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/lib-python/3/tkinter/test/test_tkinter/test_misc.py
b/lib-python/3/tkinter/test/test_tkinter/test_misc.py
deleted file mode 100644
--- a/lib-python/3/tkinter/test/test_tkinter/test_misc.py
+++ /dev/null
@@ -1,163 +0,0 @@
-import unittest
-import tkinter
-from test import support
-from tkinter.test.support import AbstractTkTest
-
-support.requires('gui')
-
-class MiscTest(AbstractTkTest, unittest.TestCase):
-
- def test_repr(self):
- t = tkinter.Toplevel(self.root, name='top')
- f = tkinter.Frame(t, name='child')
- self.assertEqual(repr(f), '<tkinter.Frame object .top.child>')
-
- def test_generated_names(self):
- t = tkinter.Toplevel(self.root)
- f = tkinter.Frame(t)
- f2 = tkinter.Frame(t)
- b = tkinter.Button(f2)
- for name in str(b).split('.'):
- self.assertFalse(name.isidentifier(), msg=repr(name))
-
- def test_tk_setPalette(self):
- root = self.root
- root.tk_setPalette('black')
- self.assertEqual(root['background'], 'black')
- root.tk_setPalette('white')
- self.assertEqual(root['background'], 'white')
- self.assertRaisesRegex(tkinter.TclError,
- '^unknown color name "spam"$',
- root.tk_setPalette, 'spam')
-
- root.tk_setPalette(background='black')
- self.assertEqual(root['background'], 'black')
- root.tk_setPalette(background='blue', highlightColor='yellow')
- self.assertEqual(root['background'], 'blue')
- self.assertEqual(root['highlightcolor'], 'yellow')
- root.tk_setPalette(background='yellow', highlightColor='blue')
- self.assertEqual(root['background'], 'yellow')
- self.assertEqual(root['highlightcolor'], 'blue')
- self.assertRaisesRegex(tkinter.TclError,
- '^unknown color name "spam"$',
- root.tk_setPalette, background='spam')
- self.assertRaisesRegex(tkinter.TclError,
- '^must specify a background color$',
- root.tk_setPalette, spam='white')
- self.assertRaisesRegex(tkinter.TclError,
- '^must specify a background color$',
- root.tk_setPalette, highlightColor='blue')
-
- def test_after(self):
- root = self.root
-
- def callback(start=0, step=1):
- nonlocal count
- count = start + step
-
- # Without function, sleeps for ms.
- self.assertIsNone(root.after(1))
-
- # Set up with callback with no args.
- count = 0
- timer1 = root.after(0, callback)
- self.assertIn(timer1, root.tk.call('after', 'info'))
- (script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
- root.update() # Process all pending events.
- self.assertEqual(count, 1)
- with self.assertRaises(tkinter.TclError):
- root.tk.call(script)
-
- # Set up with callback with args.
- count = 0
- timer1 = root.after(0, callback, 42, 11)
- root.update() # Process all pending events.
- self.assertEqual(count, 53)
-
- # Cancel before called.
- timer1 = root.after(1000, callback)
- self.assertIn(timer1, root.tk.call('after', 'info'))
- (script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
- root.after_cancel(timer1) # Cancel this event.
- self.assertEqual(count, 53)
- with self.assertRaises(tkinter.TclError):
- root.tk.call(script)
-
- def test_after_idle(self):
- root = self.root
-
- def callback(start=0, step=1):
- nonlocal count
- count = start + step
-
- # Set up with callback with no args.
- count = 0
- idle1 = root.after_idle(callback)
- self.assertIn(idle1, root.tk.call('after', 'info'))
- (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
- root.update_idletasks() # Process all pending events.
- self.assertEqual(count, 1)
- with self.assertRaises(tkinter.TclError):
- root.tk.call(script)
-
- # Set up with callback with args.
- count = 0
- idle1 = root.after_idle(callback, 42, 11)
- root.update_idletasks() # Process all pending events.
- self.assertEqual(count, 53)
-
- # Cancel before called.
- idle1 = root.after_idle(callback)
- self.assertIn(idle1, root.tk.call('after', 'info'))
- (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
- root.after_cancel(idle1) # Cancel this event.
- self.assertEqual(count, 53)
- with self.assertRaises(tkinter.TclError):
- root.tk.call(script)
-
- def test_after_cancel(self):
- root = self.root
-
- def callback():
- nonlocal count
- count += 1
-
- timer1 = root.after(5000, callback)
- idle1 = root.after_idle(callback)
-
- # No value for id raises a ValueError.
- with self.assertRaises(ValueError):
- root.after_cancel(None)
-
- # Cancel timer event.
- count = 0
- (script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
- root.tk.call(script)
- self.assertEqual(count, 1)
- root.after_cancel(timer1)
- with self.assertRaises(tkinter.TclError):
- root.tk.call(script)
- self.assertEqual(count, 1)
- with self.assertRaises(tkinter.TclError):
- root.tk.call('after', 'info', timer1)
-
- # Cancel same event - nothing happens.
- root.after_cancel(timer1)
-
- # Cancel idle event.
- count = 0
- (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
- root.tk.call(script)
- self.assertEqual(count, 1)
- root.after_cancel(idle1)
- with self.assertRaises(tkinter.TclError):
- root.tk.call(script)
- self.assertEqual(count, 1)
- with self.assertRaises(tkinter.TclError):
- root.tk.call('after', 'info', idle1)
-
-
-tests_gui = (MiscTest, )
-
-if __name__ == "__main__":
- support.run_unittest(*tests_gui)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
