Exemplo n.º 1
0
    def test_check_warnings(self):
        # Explicit tests for the test.support convenience wrapper
        wmod = self.module
        if wmod is not sys.modules['warnings']:
            self.skipTest('module to test is not loaded warnings module')
        with support.check_warnings(quiet=False) as w:
            self.assertEqual(w.warnings, [])
            wmod.simplefilter("always")
            wmod.warn("foo")
            self.assertEqual(str(w.message), "foo")
            wmod.warn("bar")
            self.assertEqual(str(w.message), "bar")
            self.assertEqual(str(w.warnings[0].message), "foo")
            self.assertEqual(str(w.warnings[1].message), "bar")
            w.reset()
            self.assertEqual(w.warnings, [])

        with support.check_warnings():
            # defaults to quiet=True without argument
            pass
        with support.check_warnings(('foo', UserWarning)):
            wmod.warn("foo")

        with self.assertRaises(AssertionError):
            with support.check_warnings(('', RuntimeWarning)):
                # defaults to quiet=False with argument
                pass
        with self.assertRaises(AssertionError):
            with support.check_warnings(('foo', RuntimeWarning)):
                wmod.warn("foo")
Exemplo n.º 2
0
    def test_compress_deprecated(self):
        tmpdir, tmpdir2, base_name =  self._create_files()

        # using compress and testing the PendingDeprecationWarning
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            with check_warnings() as w:
                warnings.simplefilter("always")
                make_tarball(base_name, 'dist', compress='compress')
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar.Z'
        self.assertTrue(os.path.exists(tarball))
        self.assertEqual(len(w.warnings), 1)

        # same test with dry_run
        os.remove(tarball)
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            with check_warnings() as w:
                warnings.simplefilter("always")
                make_tarball(base_name, 'dist', compress='compress',
                             dry_run=True)
        finally:
            os.chdir(old_dir)
        self.assertTrue(not os.path.exists(tarball))
        self.assertEqual(len(w.warnings), 1)
Exemplo n.º 3
0
    def test_issue3221(self):
        # Regression test for http://bugs.python.org/issue3221.
        def check_absolute():
            exec("from os import path", ns)
        def check_relative():
            exec("from . import relimport", ns)

        # Check both OK with __package__ and __name__ correct
        ns = dict(__package__='test', __name__='test.notarealmodule')
        check_absolute()
        check_relative()

        # Check both OK with only __name__ wrong
        ns = dict(__package__='test', __name__='notarealpkg.notarealmodule')
        check_absolute()
        check_relative()

        # Check relative fails with only __package__ wrong
        ns = dict(__package__='foo', __name__='test.notarealmodule')
        with check_warnings(('.+foo', RuntimeWarning)):
            check_absolute()
        self.assertRaises(SystemError, check_relative)

        # Check relative fails with __package__ and __name__ wrong
        ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule')
        with check_warnings(('.+foo', RuntimeWarning)):
            check_absolute()
        self.assertRaises(SystemError, check_relative)

        # Check both fail with package set to a non-string
        ns = dict(__package__=object())
        self.assertRaises(ValueError, check_absolute)
        self.assertRaises(ValueError, check_relative)
Exemplo n.º 4
0
 def test_opening_mode(self):
     try:
         # invalid mode, should raise ValueError
         fi = FileInput(mode="w")
         self.fail("FileInput should reject invalid mode argument")
     except ValueError:
         pass
     # try opening in universal newline mode
     t1 = self.writeTmp(b"A\nB\r\nC\rD", mode="wb")
     with check_warnings(('', DeprecationWarning)):
         fi = FileInput(files=t1, mode="U")
     with check_warnings(('', DeprecationWarning)):
         lines = list(fi)
     self.assertEqual(lines, ["A\n", "B\n", "C\n", "D"])
    def testFormat(self):
        # delay importing ctypes until we know we're in CPython
        from ctypes import (pythonapi, create_string_buffer, sizeof, byref,
                            c_double)
        PyOS_ascii_formatd = pythonapi.PyOS_ascii_formatd
        buf = create_string_buffer(100)

        tests = [
            ('%f', 100.0),
            ('%g', 100.0),
            ('%#g', 100.0),
            ('%#.2g', 100.0),
            ('%#.2g', 123.4567),
            ('%#.2g', 1.234567e200),
            ('%e', 1.234567e200),
            ('%e', 1.234),
            ('%+e', 1.234),
            ('%-e', 1.234),
            ]

        with check_warnings():
            for format, val in tests:
                PyOS_ascii_formatd(byref(buf), sizeof(buf),
                                   bytes(format, 'ascii'),
                                   c_double(val))
                self.assertEqual(buf.value, bytes(format % val, 'ascii'))
Exemplo n.º 6
0
 def check_all(self, modname):
     names = {}
     with support.check_warnings(
         (".* (module|package)", DeprecationWarning),
         ("", ResourceWarning),
         quiet=True):
         try:
             exec("import %s" % modname, names)
         except:
             # Silent fail here seems the best route since some modules
             # may not be available or not initialize properly in all
             # environments.
             raise FailedImport(modname)
     if not hasattr(sys.modules[modname], "__all__"):
         raise NoAll(modname)
     names = {}
     with self.subTest(module=modname):
         try:
             exec("from %s import *" % modname, names)
         except Exception as e:
             # Include the module name in the exception string
             self.fail("__all__ failure in {}: {}: {}".format(
                       modname, e.__class__.__name__, e))
         if "__builtins__" in names:
             del names["__builtins__"]
         keys = set(names)
         all_list = sys.modules[modname].__all__
         all_set = set(all_list)
         self.assertCountEqual(all_set, all_list, "in module {}".format(modname))
         self.assertEqual(keys, all_set, "in module {}".format(modname))
Exemplo n.º 7
0
 def test_resource_warning(self):
     # Issue #11453
     fd = os.open(support.TESTFN, os.O_RDONLY)
     f = asyncore.file_wrapper(fd)
     with support.check_warnings(('', ResourceWarning)):
         f = None
         support.gc_collect()
Exemplo n.º 8
0
    def test_extension_init(self):
        # the first argument, which is the name, must be a string
        self.assertRaises(AssertionError, Extension, 1, [])
        ext = Extension('name', [])
        self.assertEqual(ext.name, 'name')

        # the second argument, which is the list of files, must
        # be a list of strings
        self.assertRaises(AssertionError, Extension, 'name', 'file')
        self.assertRaises(AssertionError, Extension, 'name', ['file', 1])
        ext = Extension('name', ['file1', 'file2'])
        self.assertEqual(ext.sources, ['file1', 'file2'])

        # others arguments have defaults
        for attr in ('include_dirs', 'define_macros', 'undef_macros',
                     'library_dirs', 'libraries', 'runtime_library_dirs',
                     'extra_objects', 'extra_compile_args', 'extra_link_args',
                     'export_symbols', 'swig_opts', 'depends'):
            self.assertEqual(getattr(ext, attr), [])

        self.assertEqual(ext.language, None)
        self.assertEqual(ext.optional, None)

        # if there are unknown keyword options, warn about them
        with check_warnings() as w:
            warnings.simplefilter('always')
            ext = Extension('name', ['file1', 'file2'], chic=True)

        self.assertEqual(len(w.warnings), 1)
        self.assertEqual(str(w.warnings[0].message),
                          "Unknown Extension options: 'chic'")
Exemplo n.º 9
0
 def test_merge(self):
     with support.check_warnings(('merge is deprecated',
                                  DeprecationWarning)):
         merge = self.interp.tk.merge
         call = self.interp.tk.call
         testcases = [
             ((), ''),
             (('a',), 'a'),
             ((2,), '2'),
             (('',), '{}'),
             ('{', '\\{'),
             (('a', 'b', 'c'), 'a b c'),
             ((' ', '\t', '\r', '\n'), '{ } {\t} {\r} {\n}'),
             (('a', ' ', 'c'), 'a { } c'),
             (('a', '€'), 'a €'),
             (('a', '\U000104a2'), 'a \U000104a2'),
             (('a', b'\xe2\x82\xac'), 'a €'),
             (('a', ('b', 'c')), 'a {b c}'),
             (('a', 2), 'a 2'),
             (('a', 3.4), 'a 3.4'),
             (('a', (2, 3.4)), 'a {2 3.4}'),
             ((), ''),
             ((call('list', 1, '2', (3.4,)),), '{1 2 3.4}'),
         ]
         if tcl_version >= (8, 5):
             testcases += [
                 ((call('dict', 'create', 12, '\u20ac', b'\xe2\x82\xac', (3.4,)),),
                  '{12 € € 3.4}'),
             ]
         for args, res in testcases:
             self.assertEqual(merge(*args), res, msg=args)
         self.assertRaises(UnicodeDecodeError, merge, b'\x80')
         self.assertRaises(UnicodeEncodeError, merge, '\udc80')
Exemplo n.º 10
0
 def test_check_metadata_deprecated(self):
     # makes sure make_metadata is deprecated
     cmd = self._get_cmd()
     with check_warnings() as w:
         warnings.simplefilter("always")
         cmd.check_metadata()
         self.assertEqual(len(w.warnings), 1)
Exemplo n.º 11
0
    def test_warnings_on_cleanup(self) -> None:
        # Two kinds of warning on shutdown
        #   Issue 10888: may write to stderr if modules are nulled out
        #   ResourceWarning will be triggered by __del__
        with self.do_create() as dir:
            if os.sep != '\\':
                # Embed a backslash in order to make sure string escaping
                # in the displayed error message is dealt with correctly
                suffix = '\\check_backslash_handling'
            else:
                suffix = ''
            d = self.do_create(dir=dir, suf=suffix)

            #Check for the Issue 10888 message
            modules = [os, os.path]
            if has_stat:
                modules.append(stat)
            with support.captured_stderr() as err:
                with NulledModules(*modules):
                    d.cleanup()
            message = err.getvalue().replace('\\\\', '\\')
            self.assertIn("while cleaning up",  message)
            self.assertIn(d.name,  message)

            # Check for the resource warning
            with support.check_warnings(('Implicitly', ResourceWarning), quiet=False):
                warnings.filterwarnings("always", category=ResourceWarning)
                d.__del__()
            self.assertFalse(os.path.exists(d.name),
                        "TemporaryDirectory %s exists after __del__" % d.name)
Exemplo n.º 12
0
 def test_https_with_cadefault(self):
     handler = self.start_https_server(certfile=CERT_localhost)
     # Self-signed cert should fail verification with system certificate store
     with support.check_warnings(('', DeprecationWarning)):
         with self.assertRaises(urllib.error.URLError) as cm:
             self.urlopen("https://localhost:%s/bizarre" % handler.port,
                          cadefault=True)
Exemplo n.º 13
0
 def testWarnings(self):
     with check_warnings(quiet=True) as w:
         self.assertEqual(w.warnings, [])
         self.assertRaises(TypeError, self.FileIO, [])
         self.assertEqual(w.warnings, [])
         self.assertRaises(ValueError, self.FileIO, "/some/invalid/name", "rt")
         self.assertEqual(w.warnings, [])
Exemplo n.º 14
0
    def test___class___delayed(self):
        # See issue #23722
        test_namespace = None

        class Meta(type):
            def __new__(cls, name, bases, namespace):
                nonlocal test_namespace
                test_namespace = namespace
                return None

        # This case shouldn't trigger the __classcell__ deprecation warning
        with check_warnings() as w:
            warnings.simplefilter("always", DeprecationWarning)

            class A(metaclass=Meta):
                @staticmethod
                def f():
                    return __class__

        self.assertEqual(w.warnings, [])

        self.assertIs(A, None)

        B = type("B", (), test_namespace)
        self.assertIs(B.f(), B)
Exemplo n.º 15
0
 def test_default_values_for_zero(self):
     # Make sure that using all zeros uses the proper default values.
     # No test for daylight savings since strftime() does not change output
     # based on its value.
     expected = "2000 01 01 00 00 00 1 001"
     with support.check_warnings():
         result = time.strftime("%Y %m %d %H %M %S %w %j", (0,)*9)
     self.assertEqual(expected, result)
Exemplo n.º 16
0
 def setUp(self):
     # create empty file
     fp = open(support.TESTFN, "w+")
     fp.close()
     self.teardown_files = [support.TESTFN]
     self._warnings_manager = support.check_warnings()
     self._warnings_manager.__enter__()
     warnings.filterwarnings("ignore", ".* potential security risk .*", RuntimeWarning)
Exemplo n.º 17
0
 def setUp(self):
     # create empty file
     fp = open(support.TESTFN, 'w+')
     fp.close()
     self._warnings_manager = support.check_warnings()
     self._warnings_manager.__enter__()
     warnings.filterwarnings('ignore', '.* potential security risk .*',
                             RuntimeWarning)
Exemplo n.º 18
0
 def test_change_cwd__chdir_warning(self):
     """Check the warning message when os.chdir() fails."""
     path = TESTFN + '_does_not_exist'
     with support.check_warnings() as recorder:
         with support.change_cwd(path=path, quiet=True):
             pass
         messages = [str(w.message) for w in recorder.warnings]
     self.assertEqual(messages, ['tests may fail, unable to change CWD to: ' + path])
Exemplo n.º 19
0
 def test_misuse_global_2(self):
     source = """if 1:
         def f():
             x = 1
             global x
         """
     with support.check_warnings(('.*assigned to before global declaration',
                                  SyntaxWarning)):
         compile(source, '<testcase>', 'exec')
Exemplo n.º 20
0
 def test_misuse_global(self):
     source = """if 1:
         def f():
             print(x)
             global x
         """
     with support.check_warnings(('.*used prior to global declaration',
                                  SyntaxWarning)):
         compile(source, '<testcase>', 'exec')
Exemplo n.º 21
0
 def test_default_values_for_zero(self):
     # Make sure that using all zeros uses the proper default
     # values.  No test for daylight savings since strftime() does
     # not change output based on its value and no test for year
     # because systems vary in their support for year 0.
     expected = "2000 01 01 00 00 00 1 001"
     with support.check_warnings():
         result = time.strftime("%Y %m %d %H %M %S %w %j", (2000,)+(0,)*8)
     self.assertEqual(expected, result)
Exemplo n.º 22
0
 def test_get_loader_handles_missing_loader_attribute(self):
     global __loader__
     this_loader = __loader__
     del __loader__
     try:
         with check_warnings() as w:
             self.assertIsNotNone(pkgutil.get_loader(__name__))
             self.assertEqual(len(w.warnings), 0)
     finally:
         __loader__ = this_loader
Exemplo n.º 23
0
        async def start():
            foo_coro = foo()
            self.assertRegex(repr(foo_coro), r"<CoroWrapper .*\.foo\(\) running at .*pep492.*>")

            with support.check_warnings((r".*foo.*was never", RuntimeWarning)):
                foo_coro = None
                support.gc_collect()
                self.assertTrue(m_log.error.called)
                message = m_log.error.call_args[0][0]
                self.assertRegex(message, r"CoroWrapper.*foo.*was never")
Exemplo n.º 24
0
 def test_onlyOnePattern(self):
     with check_warnings(('', DeprecationWarning)):
         # Issue 2522: accept exactly one % pattern, and no extra chars.
         self.assertRaises(ValueError, locale.format, "%f\n", 'foo')
         self.assertRaises(ValueError, locale.format, "%f\r", 'foo')
         self.assertRaises(ValueError, locale.format, "%f\r\n", 'foo')
         self.assertRaises(ValueError, locale.format, " %f", 'foo')
         self.assertRaises(ValueError, locale.format, "%fg", 'foo')
         self.assertRaises(ValueError, locale.format, "%^g", 'foo')
         self.assertRaises(ValueError, locale.format, "%f%%", 'foo')
Exemplo n.º 25
0
    def test_at_least_import_untested_modules(self):
        with support.check_warnings(quiet=True):
            import bdb
            import cgitb
            import code

            import distutils.bcppcompiler
            import distutils.ccompiler
            import distutils.cygwinccompiler
            import distutils.emxccompiler
            import distutils.filelist
            if sys.platform.startswith('win'):
                import distutils.msvccompiler
            import distutils.text_file
            import distutils.unixccompiler

            import distutils.command.bdist_dumb
            if sys.platform.startswith('win'):
                import distutils.command.bdist_msi
            import distutils.command.bdist
            import distutils.command.bdist_rpm
            import distutils.command.bdist_wininst
            import distutils.command.build_clib
            import distutils.command.build_ext
            import distutils.command.build
            import distutils.command.clean
            import distutils.command.config
            import distutils.command.install_data
            import distutils.command.install_egg_info
            import distutils.command.install_headers
            import distutils.command.install_lib
            import distutils.command.register
            import distutils.command.sdist
            import distutils.command.upload

            import encodings
            import formatter
            import getpass
            import html.entities
            import imghdr
            import keyword
            import macurl2path
            import mailcap
            import nturl2path
            import os2emxpath
            import pstats
            import py_compile
            import sndhdr
            import tabnanny
            import timeit
            try:
                import tty     # not available on Windows
            except ImportError:
                if support.verbose:
                    print("skipping tty")
Exemplo n.º 26
0
    def test___classcell___missing(self):
        # See issue #23722
        # Some metaclasses may not pass the original namespace to type.__new__
        # We test that case here by forcibly deleting __classcell__
        class Meta(type):
            def __new__(cls, name, bases, namespace):
                namespace.pop("__classcell__", None)
                return super().__new__(cls, name, bases, namespace)

        # The default case should continue to work without any warnings
        with check_warnings() as w:
            warnings.simplefilter("always", DeprecationWarning)

            class WithoutClassRef(metaclass=Meta):
                pass

        self.assertEqual(w.warnings, [])

        # With zero-arg super() or an explicit __class__ reference, we expect
        # __build_class__ to emit a DeprecationWarning complaining that
        # __class__ was not set, and asking if __classcell__ was propagated
        # to type.__new__.
        # In Python 3.7, that warning will become a RuntimeError.
        expected_warning = ("__class__ not set.*__classcell__ propagated", DeprecationWarning)
        with check_warnings(expected_warning):
            warnings.simplefilter("always", DeprecationWarning)

            class WithClassRef(metaclass=Meta):
                def f(self):
                    return __class__

        # Check __class__ still gets set despite the warning
        self.assertIs(WithClassRef().f(), WithClassRef)

        # Check the warning is turned into an error as expected
        with warnings.catch_warnings():
            warnings.simplefilter("error", DeprecationWarning)
            with self.assertRaises(DeprecationWarning):

                class WithClassRef(metaclass=Meta):
                    def f(self):
                        return __class__
Exemplo n.º 27
0
    def test_warnings_on_cleanup(self):
        # ResourceWarning will be triggered by __del__
        with self.do_create() as dir:
            d = self.do_create(dir=dir, recurse=3)
            name = d.name

            # Check for the resource warning
            with support.check_warnings(("Implicitly", ResourceWarning), quiet=False):
                warnings.filterwarnings("always", category=ResourceWarning)
                del d
                support.gc_collect()
            self.assertFalse(os.path.exists(name), "TemporaryDirectory %s exists after __del__" % name)
Exemplo n.º 28
0
 def test_global_err_then_warn(self):
     # Bug tickler:  The SyntaxError raised for one global statement
     # shouldn't be clobbered by a SyntaxWarning issued for a later one.
     source = """if 1:
         def error(a):
             global a  # SyntaxError
         def warning():
             b = 1
             global b  # SyntaxWarning
         """
     with support.check_warnings((".*assigned to before global declaration",
                                  SyntaxWarning)):
         self._check_error(source, "local and global", lineno=2)
Exemplo n.º 29
0
 def test_splitunc(self):
     with self.assertWarns(DeprecationWarning):
         ntpath.splitunc("")
     with support.check_warnings(("", DeprecationWarning)):
         tester('ntpath.splitunc("c:\\foo\\bar")', ("", "c:\\foo\\bar"))
         tester('ntpath.splitunc("c:/foo/bar")', ("", "c:/foo/bar"))
         tester('ntpath.splitunc("\\\\conky\\mountpoint\\foo\\bar")', ("\\\\conky\\mountpoint", "\\foo\\bar"))
         tester('ntpath.splitunc("//conky/mountpoint/foo/bar")', ("//conky/mountpoint", "/foo/bar"))
         tester('ntpath.splitunc("\\\\\\conky\\mountpoint\\foo\\bar")', ("", "\\\\\\conky\\mountpoint\\foo\\bar"))
         tester('ntpath.splitunc("///conky/mountpoint/foo/bar")', ("", "///conky/mountpoint/foo/bar"))
         tester('ntpath.splitunc("\\\\conky\\\\mountpoint\\foo\\bar")', ("", "\\\\conky\\\\mountpoint\\foo\\bar"))
         tester('ntpath.splitunc("//conky//mountpoint/foo/bar")', ("", "//conky//mountpoint/foo/bar"))
         self.assertEqual(ntpath.splitunc("//conky/MOUNTPOİNT/foo/bar"), ("//conky/MOUNTPOİNT", "/foo/bar"))
Exemplo n.º 30
0
    def test_storlines(self):
        f = io.BytesIO(RETR_DATA.replace('\r\n', '\n').encode('ascii'))
        self.client.storlines('stor', f)
        self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
        # test new callback arg
        flag = []
        f.seek(0)
        self.client.storlines('stor foo', f, callback=lambda x: flag.append(None))
        self.assertTrue(flag)

        f = io.StringIO(RETR_DATA.replace('\r\n', '\n'))
        # storlines() expects a binary file, not a text file
        with support.check_warnings(('', BytesWarning), quiet=True):
            self.assertRaises(TypeError, self.client.storlines, 'stor foo', f)
Exemplo n.º 31
0
 def test_https_with_cafile(self):
     handler = self.start_https_server(certfile=CERT_localhost)
     with support.check_warnings(('', DeprecationWarning)):
         # Good cert
         data = self.urlopen("https://localhost:%s/bizarre" % handler.port,
                             cafile=CERT_localhost)
         self.assertEqual(data, b"we care a bit")
         # Bad cert
         with self.assertRaises(urllib.error.URLError) as cm:
             self.urlopen("https://localhost:%s/bizarre" % handler.port,
                          cafile=CERT_fakehostname)
         # Good cert, but mismatching hostname
         handler = self.start_https_server(certfile=CERT_fakehostname)
         with self.assertRaises(urllib.error.URLError) as cm:
             self.urlopen("https://localhost:%s/bizarre" % handler.port,
                          cafile=CERT_fakehostname)
Exemplo n.º 32
0
 def test_join_errors(self):
     # Check join() raises friendly TypeErrors.
     with support.check_warnings(('', BytesWarning), quiet=True):
         errmsg = "Can't mix strings and bytes in path components"
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.join(b'bytes', 'str')
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.join('str', b'bytes')
         # regression, see #15377
         errmsg = r'join\(\) argument must be str or bytes, not %r'
         with self.assertRaisesRegex(TypeError, errmsg % 'int'):
             self.pathmodule.join(42, 'str')
         with self.assertRaisesRegex(TypeError, errmsg % 'int'):
             self.pathmodule.join('str', 42)
         with self.assertRaisesRegex(TypeError, errmsg % 'bytearray'):
             self.pathmodule.join(bytearray(b'foo'), bytearray(b'bar'))
Exemplo n.º 33
0
 def test_relpath_errors(self):
     # Check relpath() raises friendly TypeErrors.
     with support.check_warnings(('', (BytesWarning, DeprecationWarning)),
                                 quiet=True):
         errmsg = "Can't mix strings and bytes in path components"
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.relpath(b'bytes', 'str')
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.relpath('str', b'bytes')
         errmsg = r'relpath\(\) argument must be str or bytes, not %r'
         with self.assertRaisesRegex(TypeError, errmsg % 'int'):
             self.pathmodule.relpath(42, 'str')
         with self.assertRaisesRegex(TypeError, errmsg % 'int'):
             self.pathmodule.relpath('str', 42)
         with self.assertRaisesRegex(TypeError, errmsg % 'bytearray'):
             self.pathmodule.relpath(bytearray(b'foo'), bytearray(b'bar'))
Exemplo n.º 34
0
    def test_untested_modules_can_be_imported(self):
        untested = ('bdb', 'encodings', 'formatter', 'imghdr', 'macurl2path',
                    'nturl2path', 'tabnanny')
        with support.check_warnings(quiet=True):
            for name in untested:
                try:
                    support.import_module('test.test_{}'.format(name))
                except unittest.SkipTest:
                    importlib.import_module(name)
                else:
                    self.fail('{} has tests even though test_sundry claims '
                              'otherwise'.format(name))

            import distutils.bcppcompiler
            import distutils.ccompiler
            import distutils.cygwinccompiler
            import distutils.filelist
            if sys.platform.startswith('win'):
                import distutils.msvccompiler
            import distutils.text_file
            import distutils.unixccompiler

            import distutils.command.bdist_dumb
            if sys.platform.startswith('win'):
                import distutils.command.bdist_msi
            import distutils.command.bdist
            import distutils.command.bdist_rpm
            import distutils.command.bdist_wininst
            import distutils.command.build_clib
            import distutils.command.build_ext
            import distutils.command.build
            import distutils.command.clean
            import distutils.command.config
            import distutils.command.install_data
            import distutils.command.install_egg_info
            import distutils.command.install_headers
            import distutils.command.install_lib
            import distutils.command.register
            import distutils.command.sdist
            import distutils.command.upload

            import html.entities
            try:
                import tty  # Not available on Windows
            except ImportError:
                if support.verbose:
                    print("skipping tty")
Exemplo n.º 35
0
    def test_storlines(self):
        f = io.BytesIO(RETR_DATA.replace('\r\n', '\n').encode('ascii'))
        self.client.storlines('stor', f)
        self.check_data(self.server.handler_instance.last_received_data,
                        RETR_DATA)
        # test new callback arg
        flag = []
        f.seek(0)
        self.client.storlines('stor foo',
                              f,
                              callback=lambda x: flag.append(None))
        self.assertTrue(flag)

        f = io.StringIO(RETR_DATA.replace('\r\n', '\n'))
        # storlines() expects a binary file, not a text file
        with support.check_warnings(('', BytesWarning), quiet=True):
            self.assertRaises(TypeError, self.client.storlines, 'stor foo', f)
Exemplo n.º 36
0
 def test_import_initless_directory_warning(self):
     # NOTE: to test this, we have to remove Jython's JavaImporter
     # (bound to the string '__classpath__', which of course
     # supports such directories as possible Java packages.
     #
     # For Jython 3.x we really need to rethink what it does, since
     # it repeatedly causes questions on Jython forums, but too
     # late to change for 2.7, except perhaps by some option.
     classpath_entry = sys.path.index('__classpath__')
     del sys.path[classpath_entry]
     try:
         with check_warnings(('', ImportWarning)):
             # Just a random non-package directory we always expect to be
             # somewhere in sys.path...
             self.assertRaises(ImportError, __import__, "site-packages")
     finally:
         sys.path.insert(classpath_entry, '__classpath__')
Exemplo n.º 37
0
    def test_temp_dir__existing_dir__quiet_true(self):
        """Test passing a directory that already exists with quiet=True."""
        path = tempfile.mkdtemp()
        path = os.path.realpath(path)

        try:
            with support.check_warnings() as recorder:
                with support.temp_dir(path, quiet=True) as temp_path:
                    self.assertEqual(path, temp_path)
                warnings = [str(w.message) for w in recorder.warnings]
            # Make sure temp_dir did not delete the original directory.
            self.assertTrue(os.path.isdir(path))
        finally:
            shutil.rmtree(path)

        expected = ['tests may fail, unable to create temp dir: ' + path]
        self.assertEqual(warnings, expected)
Exemplo n.º 38
0
 def test_join_errors(self):
     with support.check_warnings(('', BytesWarning), quiet=True):
         errmsg = "Can't mix strings and bytes in path components"
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.join(b'bytes', 'str')
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.join('str', b'bytes')
         with self.assertRaisesRegex(TypeError, 'int'):
             self.pathmodule.join(42, 'str')
         with self.assertRaisesRegex(TypeError, 'int'):
             self.pathmodule.join('str', 42)
         with self.assertRaisesRegex(TypeError, 'int'):
             self.pathmodule.join(42)
         with self.assertRaisesRegex(TypeError, 'list'):
             self.pathmodule.join([])
         with self.assertRaisesRegex(TypeError, 'bytearray'):
             self.pathmodule.join(bytearray(b'foo'), bytearray(b'bar'))
Exemplo n.º 39
0
 def test_parse_bytes(self):
     # UTF-8 is default encoding, US-ASCII is compatible with UTF-8,
     # UTF-16 is autodetected
     encodings = ('us-ascii', 'utf-8', 'utf-16', 'utf-16le', 'utf-16be')
     for encoding in encodings:
         self.check_parse(BytesIO(xml_bytes(self.data, encoding)))
         make_xml_file(self.data, encoding)
         self.check_parse(TESTFN)
         with open(TESTFN, 'rb') as f:
             self.check_parse(f)
         self.check_parse(BytesIO(xml_bytes(self.data, encoding, None)))
         make_xml_file(self.data, encoding, None)
         self.check_parse(TESTFN)
         with open(TESTFN, 'rb') as f:
             self.check_parse(f)
     # accept UTF-8 with BOM
     self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', 'utf-8')))
     make_xml_file(self.data, 'utf-8-sig', 'utf-8')
     self.check_parse(TESTFN)
     with open(TESTFN, 'rb') as f:
         self.check_parse(f)
     self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', None)))
     make_xml_file(self.data, 'utf-8-sig', None)
     self.check_parse(TESTFN)
     with open(TESTFN, 'rb') as f:
         self.check_parse(f)
     # accept data with declared encoding
     self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1')))
     make_xml_file(self.data, 'iso-8859-1')
     self.check_parse(TESTFN)
     with open(TESTFN, 'rb') as f:
         self.check_parse(f)
     # fail on non-UTF-8 incompatible data without declared encoding
     with self.assertRaises(SAXException):
         self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1', None)))
     make_xml_file(self.data, 'iso-8859-1', None)
     with support.check_warnings(('unclosed file', ResourceWarning)):
         # XXX Failed parser leaks an opened file.
         with self.assertRaises(SAXException):
             self.check_parse(TESTFN)
         # Collect leaked file.
         gc.collect()
     with open(TESTFN, 'rb') as f:
         with self.assertRaises(SAXException):
             self.check_parse(f)
Exemplo n.º 40
0
    def test_change_cwd__non_existent_dir__quiet_true(self):
        """Test passing a non-existent directory with quiet=True."""
        original_cwd = os.getcwd()

        with support.temp_dir() as parent_dir:
            bad_dir = os.path.join(parent_dir, 'does_not_exist')
            with support.check_warnings() as recorder:
                with support.change_cwd(bad_dir, quiet=True) as new_cwd:
                    self.assertEqual(new_cwd, original_cwd)
                    self.assertEqual(os.getcwd(), new_cwd)
                warnings = [str(w.message) for w in recorder.warnings]

        self.assertEqual(len(warnings), 1, warnings)
        warn = warnings[0]
        self.assertTrue(
            warn.startswith(f'tests may fail, unable to change '
                            f'the current working directory '
                            f'to {bad_dir!r}: '), warn)
Exemplo n.º 41
0
 def test_splitunc(self):
     with self.assertWarns(DeprecationWarning):
         ntpath.splitunc('')
     with support.check_warnings(('', DeprecationWarning)):
         tester('ntpath.splitunc("c:\\foo\\bar")', ('', 'c:\\foo\\bar'))
         tester('ntpath.splitunc("c:/foo/bar")', ('', 'c:/foo/bar'))
         tester('ntpath.splitunc("\\\\conky\\mountpoint\\foo\\bar")',
                ('\\\\conky\\mountpoint', '\\foo\\bar'))
         tester('ntpath.splitunc("//conky/mountpoint/foo/bar")',
                ('//conky/mountpoint', '/foo/bar'))
         tester('ntpath.splitunc("\\\\\\conky\\mountpoint\\foo\\bar")',
                ('', '\\\\\\conky\\mountpoint\\foo\\bar'))
         tester('ntpath.splitunc("///conky/mountpoint/foo/bar")',
                ('', '///conky/mountpoint/foo/bar'))
         tester('ntpath.splitunc("\\\\conky\\\\mountpoint\\foo\\bar")',
                ('', '\\\\conky\\\\mountpoint\\foo\\bar'))
         tester('ntpath.splitunc("//conky//mountpoint/foo/bar")',
                ('', '//conky//mountpoint/foo/bar'))
         self.assertEqual(ntpath.splitunc('//conky/MOUNTPOİNT/foo/bar'),
                          ('//conky/MOUNTPOİNT', '/foo/bar'))
Exemplo n.º 42
0
    def test_temp_dir__existing_dir__quiet_true(self):
        """Test passing a directory that already exists with quiet=True."""
        path = tempfile.mkdtemp()
        path = os.path.realpath(path)

        try:
            with support.check_warnings() as recorder:
                with os_helper.temp_dir(path, quiet=True) as temp_path:
                    self.assertEqual(path, temp_path)
                warnings = [str(w.message) for w in recorder.warnings]
            # Make sure temp_dir did not delete the original directory.
            self.assertTrue(os.path.isdir(path))
        finally:
            shutil.rmtree(path)

        self.assertEqual(len(warnings), 1, warnings)
        warn = warnings[0]
        self.assertTrue(
            warn.startswith(f'tests may fail, unable to create '
                            f'temporary directory {path!r}: '), warn)
Exemplo n.º 43
0
    def test___class___delayed(self):
        test_namespace = None

        class Meta(type):
            def __new__(cls, name, bases, namespace):
                nonlocal test_namespace
                test_namespace = namespace
                return None

        with check_warnings() as w:
            warnings.simplefilter('always', DeprecationWarning)

            class A(metaclass=Meta):
                @staticmethod
                def f():
                    return __class__

        self.assertEqual(w.warnings, [])
        self.assertIs(A, None)
        B = type('B', (), test_namespace)
        self.assertIs(B.f(), B)
Exemplo n.º 44
0
 def test_join_errors(self):
     # Check join() raises friendly TypeErrors.
     with support.check_warnings(('', BytesWarning), quiet=True):
         errmsg = "Can't mix strings and bytes in path components"
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.join(b'bytes', 'str')
         with self.assertRaisesRegex(TypeError, errmsg):
             self.pathmodule.join('str', b'bytes')
         # regression, see #15377
         # TODO: skip now by hhatto
         return
         with self.assertRaisesRegex(TypeError, 'int'):
             self.pathmodule.join(42, 'str')
         with self.assertRaisesRegex(TypeError, 'int'):
             self.pathmodule.join('str', 42)
         with self.assertRaisesRegex(TypeError, 'int'):
             self.pathmodule.join(42)
         with self.assertRaisesRegex(TypeError, 'list'):
             self.pathmodule.join([])
         with self.assertRaisesRegex(TypeError, 'bytearray'):
             self.pathmodule.join(bytearray(b'foo'), bytearray(b'bar'))
Exemplo n.º 45
0
    def test_exec(self):
        g = {}
        exec('z = 1', g)
        if '__builtins__' in g:
            del g['__builtins__']
        self.assertEqual(g, {'z': 1})

        exec('z = 1+1', g)
        if '__builtins__' in g:
            del g['__builtins__']
        self.assertEqual(g, {'z': 2})
        g = {}
        l = {}

        with check_warnings():
            warnings.filterwarnings("ignore", "global statement",
                    module="<string>")
            exec('global a; a = 1; b = 2', g, l)
        if '__builtins__' in g:
            del g['__builtins__']
        if '__builtins__' in l:
            del l['__builtins__']
        self.assertEqual((g, l), ({'a': 1}, {'b': 2}))
Exemplo n.º 46
0
    def test___class___delayed(self):
        # See issue #23722
        test_namespace = None

        class Meta(type):
            def __new__(cls, name, bases, namespace):
                nonlocal test_namespace
                test_namespace = namespace
                return None

        # This case shouldn't trigger the __classcell__ deprecation warning
        with check_warnings() as w:
            warnings.simplefilter("always", DeprecationWarning)
            class A(metaclass=Meta):
                @staticmethod
                def f():
                    return __class__
        self.assertEqual(w.warnings, [])

        self.assertIs(A, None)

        B = type("B", (), test_namespace)
        self.assertIs(B.f(), B)
 def test_unquoting(self):
     # Make sure unquoting of all ASCII values works
     escape_list = []
     for num in range(128):
         given = hexescape(chr(num))
         expect = chr(num)
         result = urllib.parse.unquote(given)
         self.assertEqual(expect, result,
                          "using unquote(): %r != %r" % (expect, result))
         result = urllib.parse.unquote_plus(given)
         self.assertEqual(expect, result,
                          "using unquote_plus(): %r != %r" %
                          (expect, result))
         escape_list.append(given)
     escape_string = ''.join(escape_list)
     del escape_list
     result = urllib.parse.unquote(escape_string)
     self.assertEqual(result.count('%'), 1,
                      "using unquote(): not all characters escaped: "
                      "%s" % result)
     self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, None)
     self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, ())
     with support.check_warnings(('', BytesWarning), quiet=True):
         self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, b'')
 def test_import_initless_directory_warning(self):
     with check_warnings(('', ImportWarning)):
         # Just a random non-package directory we always expect to be
         # somewhere in sys.path...
         self.assertRaises(ImportError, __import__, "site-packages")
Exemplo n.º 49
0
 def test_SO_value(self):
     with check_warnings(('', DeprecationWarning)):
         self.assertEqual(sysconfig.get_config_var('SO'),
                          sysconfig.get_config_var('EXT_SUFFIX'))
Exemplo n.º 50
0
 def test_CheckBinary(self):
     with (test_support.check_warnings() if sys.version_info[0] >= 3 else
           test_support.check_py3k_warnings()):
         b = sqlite.Binary(
             chr(0).encode() +
             b"'" if sys.version_info[0] >= 3 else chr(0) + b"'")
Exemplo n.º 51
0
 def test_non_str_argument(self):
     # Issue #15778
     with check_warnings(('', BytesWarning), quiet=True):
         arg = b'abc'
         exc = ImportError(arg)
         self.assertEqual(str(arg), str(exc))
Exemplo n.º 52
0
"""Test script for the binhex C module

   Uses the mechanism of the python binhex module
   Based on an original test by Roger E. Masse.
"""
import unittest
from test import support

with support.check_warnings(('', DeprecationWarning)):
    binhex = support.import_fresh_module('binhex')


class BinHexTestCase(unittest.TestCase):
    def setUp(self):
        # binhex supports only file names encodable to Latin1
        self.fname1 = support.TESTFN_ASCII + "1"
        self.fname2 = support.TESTFN_ASCII + "2"
        self.fname3 = support.TESTFN_ASCII + "very_long_filename__very_long_filename__very_long_filename__very_long_filename__"

    def tearDown(self):
        support.unlink(self.fname1)
        support.unlink(self.fname2)
        support.unlink(self.fname3)

    DATA = b'Jack is my hero'

    def test_binhex(self):
        with open(self.fname1, 'wb') as f:
            f.write(self.DATA)

        binhex.binhex(self.fname1, self.fname2)
Exemplo n.º 53
0
 def _test_format(self, format, value, out, **format_opts):
     with support.check_warnings(('', DeprecationWarning)):
         self._test_formatfunc(format, value, out,
             func=locale.format, **format_opts)
Exemplo n.º 54
0
 def test_ushort_max(self):
     with support.check_warnings() as w:
         ts.T_USHORT = USHRT_MAX + 1
         self.has_warned(w)
Exemplo n.º 55
0
 def test_short_min(self):
     with support.check_warnings() as w:
         ts.T_SHORT = SHRT_MIN - 1
         self.has_warned(w)
Exemplo n.º 56
0
 def test_ubyte_max(self):
     with support.check_warnings() as w:
         ts.T_UBYTE = UCHAR_MAX + 1
         self.has_warned(w)
Exemplo n.º 57
0
 def test_byte_min(self):
     with support.check_warnings() as w:
         ts.T_BYTE = CHAR_MIN - 1
         self.has_warned(w)
Exemplo n.º 58
0
 def test_deprecated_parse_qsl(self):
     # this func is moved to urllib.parse, this is just a sanity check
     with check_warnings(('cgi.parse_qsl is deprecated, use urllib.parse.'
                          'parse_qsl instead', DeprecationWarning)):
         self.assertEqual([('a', 'A1'), ('b', 'B2'), ('B', 'B3')],
                          cgi.parse_qsl('a=A1&b=B2&B=B3'))
Exemplo n.º 59
0
 def get_collector(self):
     with support.check_warnings(("", DeprecationWarning), quite=False):
         return EventCollector(strict=True, convert_charrefs=False)
Exemplo n.º 60
0
 def test_certfile_arg_warn(self):
     with support.check_warnings(('', DeprecationWarning)):
         with mock.patch.object(self.imap_class, 'open'):
             with mock.patch.object(self.imap_class, '_connect'):
                 self.imap_class('localhost', 143, certfile=CERTFILE)