def import_importlib(module_name):
    """Import a module from importlib both w/ and w/o _frozen_importlib."""
    fresh = ('importlib',) if '.' in module_name else ()
    frozen = support.import_fresh_module(module_name)
    source = support.import_fresh_module(module_name, fresh=fresh,
                                         blocked=('_frozen_importlib', '_frozen_importlib_external'))
    return {'Frozen': frozen, 'Source': source}

def import_importlib(module_name):
    """Import a module from importlib both w/ and w/o _frozen_importlib."""
    fresh = ('importlib',) if '.' in module_name else ()
    frozen = support.import_fresh_module(module_name)
    source = support.import_fresh_module(module_name, fresh=fresh,
                                         blocked=('_frozen_importlib',))
    return frozen, source

 def test_environment(self):
     webbrowser = support.import_fresh_module('webbrowser')
     try:
         browser = webbrowser.get().name
     except (webbrowser.Error, AttributeError) as err:
         self.skipTest(str(err))
     with support.EnvironmentVarGuard() as env:
         env["BROWSER"] = browser
         webbrowser = support.import_fresh_module('webbrowser')
         webbrowser.get()

    def test_get(self):
        webbrowser = support.import_fresh_module('webbrowser')
        self.assertIsNone(webbrowser._tryorder)
        self.assertFalse(webbrowser._browsers)

        with self.assertRaises(webbrowser.Error):
            webbrowser.get('fakebrowser')
        self.assertIsNotNone(webbrowser._tryorder)

 def testWithoutThreading(self):
     if not hasattr(support, "import_fresh_module"):
         return
     module = support.import_fresh_module("bz2file", blocked=("threading",))
     with module.BZ2File(self.filename, "wb") as f:
         f.write(b"abc")
     with module.BZ2File(self.filename, "rb") as f:
         self.assertEqual(f.read(), b"abc")

    def test_environment_preferred(self):
        webbrowser = support.import_fresh_module('webbrowser')
        try:
            webbrowser.get()
            least_preferred_browser = webbrowser.get(webbrowser._tryorder[-1]).name
        except (webbrowser.Error, AttributeError, IndexError) as err:
            self.skipTest(str(err))

        with support.EnvironmentVarGuard() as env:
            env["BROWSER"] = least_preferred_browser
            webbrowser = support.import_fresh_module('webbrowser')
            self.assertEqual(webbrowser.get().name, least_preferred_browser)

        with support.EnvironmentVarGuard() as env:
            env["BROWSER"] = sys.executable
            webbrowser = support.import_fresh_module('webbrowser')
            self.assertEqual(webbrowser.get().name, sys.executable)

    def test_register(self):
        webbrowser = support.import_fresh_module('webbrowser')
        self.assertIsNone(webbrowser._tryorder)
        self.assertFalse(webbrowser._browsers)

        class ExampleBrowser:
            pass
        webbrowser.register('Example1', ExampleBrowser)
        self.assertTrue(webbrowser._tryorder)
        self.assertEqual(webbrowser._tryorder[-1], 'Example1')
        self.assertTrue(webbrowser._browsers)
        self.assertIn('example1', webbrowser._browsers)
        self.assertEqual(webbrowser._browsers['example1'], [ExampleBrowser, None])

import unittest.mock
from test import support
import builtins
import contextlib
import copy
import io
import os
import pickle
import shutil
import subprocess
import sys

py_uuid = support.import_fresh_module('uuid', blocked=['_uuid'])
c_uuid = support.import_fresh_module('uuid', fresh=['_uuid'])


def importable(name):
    try:
        __import__(name)
        return True
    except:
        return False


class BaseTestUUID:
    uuid = None

    def test_UUID(self):
        equal = self.assertEqual
        ascending = []
        for (string, curly, hex, bytes, bytes_le, fields, integer, urn,

import unittest
import sys
from test.support import import_fresh_module, run_unittest
TESTS = 'test.datetimetester'
# XXX: import_fresh_module() is supposed to leave sys.module cache untouched,
# XXX: but it does not, so we have to save and restore it ourselves.
save_sys_modules = sys.modules.copy()
try:
    pure_tests = import_fresh_module(TESTS, fresh=['datetime', '_strptime'],
                                     blocked=['_datetime'])
    fast_tests = import_fresh_module(TESTS, fresh=['datetime',
                                                   '_datetime', '_strptime'])
finally:
    sys.modules.clear()
    sys.modules.update(save_sys_modules)
test_modules = [pure_tests, fast_tests]
test_suffixes = ["_Pure", "_Fast"]

for module, suffix in zip(test_modules, test_suffixes):
    for name, cls in module.__dict__.items():
        if isinstance(cls, type) and issubclass(cls, unittest.TestCase):
            name += suffix
            cls.__name__ = name
            globals()[name] = cls
            def setUp(self, module=module, setup=cls.setUp):
                self._save_sys_modules = sys.modules.copy()
                sys.modules[TESTS] = module
                sys.modules['datetime'] = module.datetime_module
                sys.modules['_strptime'] = module._strptime
                setup(self)
            def tearDown(self, teardown=cls.tearDown):

#

#
# Usage: python deccheck.py [--short|--medium|--long|--all]
#

import sys, random
from copy import copy
from collections import defaultdict
from test.support import import_fresh_module
from randdec import randfloat, all_unary, all_binary, all_ternary
from randdec import unary_optarg, binary_optarg, ternary_optarg
from formathelper import rand_format, rand_locale
from _pydecimal import _dec_from_triple

C = import_fresh_module("decimal", fresh=["_decimal"])
P = import_fresh_module("decimal", blocked=["_decimal"])
EXIT_STATUS = 0


# Contains all categories of Decimal methods.
Functions = {
    # Plain unary:
    "unary": (
        "__abs__",
        "__bool__",
        "__ceil__",
        "__complex__",
        "__copy__",
        "__floor__",
        "__float__",

import unittest
import sys
import os
from test import support

# Skip this test if the _tkinter module wasn't built.
_tkinter = support.import_module("_tkinter")

# Make sure tkinter._fix runs to set up the environment
support.import_fresh_module("tkinter")

from tkinter import Tcl
from _tkinter import TclError

try:
    from _testcapi import INT_MAX, PY_SSIZE_T_MAX
except ImportError:
    INT_MAX = PY_SSIZE_T_MAX = sys.maxsize

tcl_version = _tkinter.TCL_VERSION.split(".")
try:
    for i in range(len(tcl_version)):
        tcl_version[i] = int(tcl_version[i])
except ValueError:
    pass
tcl_version = tuple(tcl_version)

_tk_patchlevel = None


def get_tk_patchlevel():

# xml.etree test for cElementTree
import sys, struct
from test import support
from test.support import import_fresh_module
import types
import unittest

cET = import_fresh_module('xml.etree.ElementTree',
                          fresh=['_elementtree'])
cET_alias = import_fresh_module('xml.etree.cElementTree',
                                fresh=['_elementtree', 'xml.etree'])


class MiscTests(unittest.TestCase):
    # Issue #8651.
    @support.bigmemtest(size=support._2G + 100, memuse=1, dry_run=False)
    def test_length_overflow(self, size):
        data = b'x' * size
        parser = cET.XMLParser()
        try:
            self.assertRaises(OverflowError, parser.feed, data)
        finally:
            data = None

    def test_del_attribute(self):
        element = cET.Element('tag')

        element.tag = 'TAG'
        with self.assertRaises(AttributeError):
            del element.tag
        self.assertEqual(element.tag, 'TAG')

import unittest
from test.support import import_module, import_fresh_module

# Skip test if _thread or _tkinter wasn't built or idlelib was deleted.
import_module('threading')  # imported by PyShell, imports _thread
tk = import_module('tkinter')  # imports _tkinter
idletest = import_module('idlelib.idle_test')
# Make sure TCL_LIBRARY is set properly on Windows.  Note that this will
# cause a warning about test_idle modifying the environment
import_fresh_module('tkinter._fix')

# Without test_main present, regrtest.runtest_inner (line1219) calls
# unittest.TestLoader().loadTestsFromModule(this_module) which calls
# load_tests() if it finds it. (Unittest.main does the same.)
load_tests = idletest.load_tests

if __name__ == '__main__':
    unittest.main(verbosity=2, exit=False)

 def testWithoutThreading(self):
     bz2 = support.import_fresh_module("bz2", blocked=("threading",))
     with bz2.BZ2File(self.filename, "wb") as f:
         f.write(b"abc")
     with bz2.BZ2File(self.filename, "rb") as f:
         self.assertEqual(f.read(), b"abc")

"""Unittests for heapq."""

import sys
import random
import unittest

from test import support
from unittest import TestCase, skipUnless

py_heapq = support.import_fresh_module('heapq', blocked=['_heapq'])
c_heapq = support.import_fresh_module('heapq', fresh=['_heapq'])

# _heapq.nlargest/nsmallest are saved in heapq._nlargest/_smallest when
# _heapq is imported, so check them there
func_names = ['heapify', 'heappop', 'heappush', 'heappushpop',
              'heapreplace', '_heapreplace_max']

class TestModules(TestCase):
    def test_py_functions(self):
        for fname in func_names:
            self.assertEqual(getattr(py_heapq, fname).__module__, 'heapq')

    @skipUnless(c_heapq, 'requires _heapq')
    def test_c_functions(self):
        for fname in func_names:
            self.assertEqual(getattr(c_heapq, fname).__module__, '_heapq')


class TestHeap:

    def test_push_pop(self):

 def test_no_frozen_importlib(self):
     # Should be able to import w/o _frozen_importlib being defined.
     module = support.import_fresh_module('importlib', blocked=['_frozen_importlib'])
     self.assertFalse(isinstance(module.__loader__,
                                 machinery.FrozenImporter))

import collections
import sys
import unittest
from test import support
from weakref import proxy
import pickle
from random import choice

import functools

original_functools = functools
py_functools = support.import_fresh_module('functools', blocked=['_functools'])
c_functools = support.import_fresh_module('functools', fresh=['_functools'])

class BaseTest(unittest.TestCase):

    """Base class required for testing C and Py implementations."""

    def setUp(self):

        # The module must be explicitly set so that the proper
        # interaction between the c module and the python module
        # can be controlled.
        self.partial = self.module.partial
        super(BaseTest, self).setUp()

class BaseTestC(BaseTest):
    module = c_functools

class BaseTestPy(BaseTest):
    module = py_functools

 def test_synthesize(self):
     webbrowser = support.import_fresh_module('webbrowser')
     name = os.path.basename(sys.executable).lower()
     webbrowser.register(name, None, webbrowser.GenericBrowser(name))
     webbrowser.get(sys.executable)

"""Unittests for heapq."""

import sys
import random
import unittest

from test import support
from unittest import TestCase, skipUnless
from operator import itemgetter

py_heapq = support.import_fresh_module("heapq", blocked=["_heapq"])
c_heapq = support.import_fresh_module("heapq", fresh=["_heapq"])

# _heapq.nlargest/nsmallest are saved in heapq._nlargest/_smallest when
# _heapq is imported, so check them there
func_names = [
    "heapify",
    "heappop",
    "heappush",
    "heappushpop",
    "heapreplace",
    "_heappop_max",
    "_heapreplace_max",
    "_heapify_max",
]


class TestModules(TestCase):
    def test_py_functions(self):
        for fname in func_names:
            self.assertEqual(getattr(py_heapq, fname).__module__, "heapq")

import unittest
import pickle
import sys

from test import support

py_operator = support.import_fresh_module('operator', blocked=['_operator'])
c_operator = support.import_fresh_module('operator', fresh=['_operator'])

class Seq1:
    def __init__(self, lst):
        self.lst = lst
    def __len__(self):
        return len(self.lst)
    def __getitem__(self, i):
        return self.lst[i]
    def __add__(self, other):
        return self.lst + other.lst
    def __mul__(self, other):
        return self.lst * other
    def __rmul__(self, other):
        return other * self.lst

class Seq2(object):
    def __init__(self, lst):
        self.lst = lst
    def __len__(self):
        return len(self.lst)
    def __getitem__(self, i):
        return self.lst[i]
    def __add__(self, other):