EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

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

import unittest\r
import sys\r
from test.test_support import check_py3k_warnings, CleanImport, run_unittest\r
import warnings\r
\r
if not sys.py3kwarning:\r
    raise unittest.SkipTest('%s must be run with the -3 flag' % __name__)\r
\r
try:\r
    from test.test_support import __warningregistry__ as _registry\r
except ImportError:\r
    def check_deprecated_module(module_name):\r
        return False\r
else:\r
    past_warnings = _registry.keys()\r
    del _registry\r
    def check_deprecated_module(module_name):\r
        """Lookup the past warnings for module already loaded using\r
        test_support.import_module(..., deprecated=True)\r
        """\r
        return any(module_name in msg and ' removed' in msg\r
                   and issubclass(cls, DeprecationWarning)\r
                   and (' module' in msg or ' package' in msg)\r
                   for (msg, cls, line) in past_warnings)\r
\r
def reset_module_registry(module):\r
    try:\r
        registry = module.__warningregistry__\r
    except AttributeError:\r
        pass\r
    else:\r
        registry.clear()\r
\r
class TestPy3KWarnings(unittest.TestCase):\r
\r
    def assertWarning(self, _, warning, expected_message):\r
        self.assertEqual(str(warning.message), expected_message)\r
\r
    def assertNoWarning(self, _, recorder):\r
        self.assertEqual(len(recorder.warnings), 0)\r
\r
    def test_backquote(self):\r
        expected = 'backquote not supported in 3.x; use repr()'\r
        with check_py3k_warnings((expected, SyntaxWarning)):\r
            exec "`2`" in {}\r
\r
    def test_paren_arg_names(self):\r
        expected = 'parenthesized argument names are invalid in 3.x'\r
        def check(s):\r
            with check_py3k_warnings((expected, SyntaxWarning)):\r
                exec s in {}\r
        check("def f((x)): pass")\r
        check("def f((((x))), (y)): pass")\r
        check("def f((x), (((y))), m=32): pass")\r
        # Something like def f((a, (b))): pass will raise the tuple\r
        # unpacking warning.\r
\r
    def test_forbidden_names(self):\r
        # So we don't screw up our globals\r
        def safe_exec(expr):\r
            def f(**kwargs): pass\r
            exec expr in {'f' : f}\r
\r
        tests = [("True", "assignment to True or False is forbidden in 3.x"),\r
                 ("False", "assignment to True or False is forbidden in 3.x"),\r
                 ("nonlocal", "nonlocal is a keyword in 3.x")]\r
        with check_py3k_warnings(('', SyntaxWarning)) as w:\r
            for keyword, expected in tests:\r
                safe_exec("{0} = False".format(keyword))\r
                self.assertWarning(None, w, expected)\r
                w.reset()\r
                try:\r
                    safe_exec("obj.{0} = True".format(keyword))\r
                except NameError:\r
                    pass\r
                self.assertWarning(None, w, expected)\r
                w.reset()\r
                safe_exec("def {0}(): pass".format(keyword))\r
                self.assertWarning(None, w, expected)\r
                w.reset()\r
                safe_exec("class {0}: pass".format(keyword))\r
                self.assertWarning(None, w, expected)\r
                w.reset()\r
                safe_exec("def f({0}=43): pass".format(keyword))\r
                self.assertWarning(None, w, expected)\r
                w.reset()\r
\r
\r
    def test_type_inequality_comparisons(self):\r
        expected = 'type inequality comparisons not supported in 3.x'\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(int < str, w, expected)\r
            w.reset()\r
            self.assertWarning(type < object, w, expected)\r
\r
    def test_object_inequality_comparisons(self):\r
        expected = 'comparing unequal types not supported in 3.x'\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(str < [], w, expected)\r
            w.reset()\r
            self.assertWarning(object() < (1, 2), w, expected)\r
\r
    def test_dict_inequality_comparisons(self):\r
        expected = 'dict inequality comparisons not supported in 3.x'\r
        with check_py3k_warnings() as w:\r
            self.assertWarning({} < {2:3}, w, expected)\r
            w.reset()\r
            self.assertWarning({} <= {}, w, expected)\r
            w.reset()\r
            self.assertWarning({} > {2:3}, w, expected)\r
            w.reset()\r
            self.assertWarning({2:3} >= {}, w, expected)\r
\r
    def test_cell_inequality_comparisons(self):\r
        expected = 'cell comparisons not supported in 3.x'\r
        def f(x):\r
            def g():\r
                return x\r
            return g\r
        cell0, = f(0).func_closure\r
        cell1, = f(1).func_closure\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(cell0 == cell1, w, expected)\r
            w.reset()\r
            self.assertWarning(cell0 < cell1, w, expected)\r
\r
    def test_code_inequality_comparisons(self):\r
        expected = 'code inequality comparisons not supported in 3.x'\r
        def f(x):\r
            pass\r
        def g(x):\r
            pass\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(f.func_code < g.func_code, w, expected)\r
            w.reset()\r
            self.assertWarning(f.func_code <= g.func_code, w, expected)\r
            w.reset()\r
            self.assertWarning(f.func_code >= g.func_code, w, expected)\r
            w.reset()\r
            self.assertWarning(f.func_code > g.func_code, w, expected)\r
\r
    def test_builtin_function_or_method_comparisons(self):\r
        expected = ('builtin_function_or_method '\r
                    'order comparisons not supported in 3.x')\r
        func = eval\r
        meth = {}.get\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(func < meth, w, expected)\r
            w.reset()\r
            self.assertWarning(func > meth, w, expected)\r
            w.reset()\r
            self.assertWarning(meth <= func, w, expected)\r
            w.reset()\r
            self.assertWarning(meth >= func, w, expected)\r
            w.reset()\r
            self.assertNoWarning(meth == func, w)\r
            self.assertNoWarning(meth != func, w)\r
            lam = lambda x: x\r
            self.assertNoWarning(lam == func, w)\r
            self.assertNoWarning(lam != func, w)\r
\r
    def test_frame_attributes(self):\r
        template = "%s has been removed in 3.x"\r
        f = sys._getframe(0)\r
        for attr in ("f_exc_traceback", "f_exc_value", "f_exc_type"):\r
            expected = template % attr\r
            with check_py3k_warnings() as w:\r
                self.assertWarning(getattr(f, attr), w, expected)\r
                w.reset()\r
                self.assertWarning(setattr(f, attr, None), w, expected)\r
\r
    def test_sort_cmp_arg(self):\r
        expected = "the cmp argument is not supported in 3.x"\r
        lst = range(5)\r
        cmp = lambda x,y: -1\r
\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(lst.sort(cmp=cmp), w, expected)\r
            w.reset()\r
            self.assertWarning(sorted(lst, cmp=cmp), w, expected)\r
            w.reset()\r
            self.assertWarning(lst.sort(cmp), w, expected)\r
            w.reset()\r
            self.assertWarning(sorted(lst, cmp), w, expected)\r
\r
    def test_sys_exc_clear(self):\r
        expected = 'sys.exc_clear() not supported in 3.x; use except clauses'\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(sys.exc_clear(), w, expected)\r
\r
    def test_methods_members(self):\r
        expected = '__members__ and __methods__ not supported in 3.x'\r
        class C:\r
            __methods__ = ['a']\r
            __members__ = ['b']\r
        c = C()\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(dir(c), w, expected)\r
\r
    def test_softspace(self):\r
        expected = 'file.softspace not supported in 3.x'\r
        with file(__file__) as f:\r
            with check_py3k_warnings() as w:\r
                self.assertWarning(f.softspace, w, expected)\r
            def set():\r
                f.softspace = 0\r
            with check_py3k_warnings() as w:\r
                self.assertWarning(set(), w, expected)\r
\r
    def test_slice_methods(self):\r
        class Spam(object):\r
            def __getslice__(self, i, j): pass\r
            def __setslice__(self, i, j, what): pass\r
            def __delslice__(self, i, j): pass\r
        class Egg:\r
            def __getslice__(self, i, h): pass\r
            def __setslice__(self, i, j, what): pass\r
            def __delslice__(self, i, j): pass\r
\r
        expected = "in 3.x, __{0}slice__ has been removed; use __{0}item__"\r
\r
        for obj in (Spam(), Egg()):\r
            with check_py3k_warnings() as w:\r
                self.assertWarning(obj[1:2], w, expected.format('get'))\r
                w.reset()\r
                del obj[3:4]\r
                self.assertWarning(None, w, expected.format('del'))\r
                w.reset()\r
                obj[4:5] = "eggs"\r
                self.assertWarning(None, w, expected.format('set'))\r
\r
    def test_tuple_parameter_unpacking(self):\r
        expected = "tuple parameter unpacking has been removed in 3.x"\r
        with check_py3k_warnings((expected, SyntaxWarning)):\r
            exec "def f((a, b)): pass"\r
\r
    def test_buffer(self):\r
        expected = 'buffer() not supported in 3.x'\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(buffer('a'), w, expected)\r
\r
    def test_file_xreadlines(self):\r
        expected = ("f.xreadlines() not supported in 3.x, "\r
                    "try 'for line in f' instead")\r
        with file(__file__) as f:\r
            with check_py3k_warnings() as w:\r
                self.assertWarning(f.xreadlines(), w, expected)\r
\r
    def test_hash_inheritance(self):\r
        with check_py3k_warnings() as w:\r
            # With object as the base class\r
            class WarnOnlyCmp(object):\r
                def __cmp__(self, other): pass\r
            self.assertEqual(len(w.warnings), 0)\r
            w.reset()\r
            class WarnOnlyEq(object):\r
                def __eq__(self, other): pass\r
            self.assertEqual(len(w.warnings), 1)\r
            self.assertWarning(None, w,\r
                 "Overriding __eq__ blocks inheritance of __hash__ in 3.x")\r
            w.reset()\r
            class WarnCmpAndEq(object):\r
                def __cmp__(self, other): pass\r
                def __eq__(self, other): pass\r
            self.assertEqual(len(w.warnings), 1)\r
            self.assertWarning(None, w,\r
                 "Overriding __eq__ blocks inheritance of __hash__ in 3.x")\r
            w.reset()\r
            class NoWarningOnlyHash(object):\r
                def __hash__(self): pass\r
            self.assertEqual(len(w.warnings), 0)\r
            # With an intermediate class in the heirarchy\r
            class DefinesAllThree(object):\r
                def __cmp__(self, other): pass\r
                def __eq__(self, other): pass\r
                def __hash__(self): pass\r
            class WarnOnlyCmp(DefinesAllThree):\r
                def __cmp__(self, other): pass\r
            self.assertEqual(len(w.warnings), 0)\r
            w.reset()\r
            class WarnOnlyEq(DefinesAllThree):\r
                def __eq__(self, other): pass\r
            self.assertEqual(len(w.warnings), 1)\r
            self.assertWarning(None, w,\r
                 "Overriding __eq__ blocks inheritance of __hash__ in 3.x")\r
            w.reset()\r
            class WarnCmpAndEq(DefinesAllThree):\r
                def __cmp__(self, other): pass\r
                def __eq__(self, other): pass\r
            self.assertEqual(len(w.warnings), 1)\r
            self.assertWarning(None, w,\r
                 "Overriding __eq__ blocks inheritance of __hash__ in 3.x")\r
            w.reset()\r
            class NoWarningOnlyHash(DefinesAllThree):\r
                def __hash__(self): pass\r
            self.assertEqual(len(w.warnings), 0)\r
\r
    def test_operator(self):\r
        from operator import isCallable, sequenceIncludes\r
\r
        callable_warn = ("operator.isCallable() is not supported in 3.x. "\r
                         "Use hasattr(obj, '__call__').")\r
        seq_warn = ("operator.sequenceIncludes() is not supported "\r
                    "in 3.x. Use operator.contains().")\r
        with check_py3k_warnings() as w:\r
            self.assertWarning(isCallable(self), w, callable_warn)\r
            w.reset()\r
            self.assertWarning(sequenceIncludes(range(3), 2), w, seq_warn)\r
\r
\r
class TestStdlibRemovals(unittest.TestCase):\r
\r
    # test.testall not tested as it executes all unit tests as an\r
    # import side-effect.\r
    all_platforms = ('audiodev', 'imputil', 'mutex', 'user', 'new', 'rexec',\r
                        'Bastion', 'compiler', 'dircache', 'mimetools',\r
                        'fpformat', 'ihooks', 'mhlib', 'statvfs', 'htmllib',\r
                        'sgmllib', 'rfc822', 'sunaudio')\r
    inclusive_platforms = {'irix' : ('pure', 'AL', 'al', 'CD', 'cd', 'cddb',\r
                                     'cdplayer', 'CL', 'cl', 'DEVICE', 'GL',\r
                                     'gl', 'ERRNO', 'FILE', 'FL', 'flp', 'fl',\r
                                     'fm', 'GET', 'GLWS', 'imgfile', 'IN',\r
                                     'IOCTL', 'jpeg', 'panel', 'panelparser',\r
                                     'readcd', 'SV', 'torgb', 'WAIT'),\r
                          'darwin' : ('autoGIL', 'Carbon', 'OSATerminology',\r
                                      'icglue', 'Nav',\r
                                      # MacOS should (and does) give a Py3kWarning, but one of the\r
                                      # earlier tests already imports the MacOS extension which causes\r
                                      # this test to fail. Disabling the test for 'MacOS' avoids this\r
                                      # spurious test failure.\r
                                      #'MacOS',\r
                                      'aepack',\r
                                      'aetools', 'aetypes', 'applesingle',\r
                                      'appletrawmain', 'appletrunner',\r
                                      'argvemulator', 'bgenlocations',\r
                                      'EasyDialogs', 'macerrors', 'macostools',\r
                                      'findertools', 'FrameWork', 'ic',\r
                                      'gensuitemodule', 'icopen', 'macresource',\r
                                      'MiniAEFrame', 'pimp', 'PixMapWrapper',\r
                                      'terminalcommand', 'videoreader',\r
                                      '_builtinSuites', 'CodeWarrior',\r
                                      'Explorer', 'Finder', 'Netscape',\r
                                      'StdSuites', 'SystemEvents', 'Terminal',\r
                                      'cfmfile', 'bundlebuilder', 'buildtools',\r
                                      'ColorPicker', 'Audio_mac'),\r
                           'sunos5' : ('sunaudiodev', 'SUNAUDIODEV'),\r
                          }\r
    optional_modules = ('bsddb185', 'Canvas', 'dl', 'linuxaudiodev', 'imageop',\r
                        'sv', 'bsddb', 'dbhash')\r
\r
    def check_removal(self, module_name, optional=False):\r
        """Make sure the specified module, when imported, raises a\r
        DeprecationWarning and specifies itself in the message."""\r
        with CleanImport(module_name), warnings.catch_warnings():\r
            warnings.filterwarnings("error", ".+ (module|package) .+ removed",\r
                                    DeprecationWarning, __name__)\r
            warnings.filterwarnings("error", ".+ removed .+ (module|package)",\r
                                    DeprecationWarning, __name__)\r
            try:\r
                __import__(module_name, level=0)\r
            except DeprecationWarning as exc:\r
                self.assertIn(module_name, exc.args[0],\r
                              "%s warning didn't contain module name"\r
                              % module_name)\r
            except ImportError:\r
                if not optional:\r
                    self.fail("Non-optional module {0} raised an "\r
                              "ImportError.".format(module_name))\r
            else:\r
                # For extension modules, check the __warningregistry__.\r
                # They won't rerun their init code even with CleanImport.\r
                if not check_deprecated_module(module_name):\r
                    self.fail("DeprecationWarning not raised for {0}"\r
                              .format(module_name))\r
\r
    def test_platform_independent_removals(self):\r
        # Make sure that the modules that are available on all platforms raise\r
        # the proper DeprecationWarning.\r
        for module_name in self.all_platforms:\r
            self.check_removal(module_name)\r
\r
    def test_platform_specific_removals(self):\r
        # Test the removal of platform-specific modules.\r
        for module_name in self.inclusive_platforms.get(sys.platform, []):\r
            self.check_removal(module_name, optional=True)\r
\r
    def test_optional_module_removals(self):\r
        # Test the removal of modules that may or may not be built.\r
        for module_name in self.optional_modules:\r
            self.check_removal(module_name, optional=True)\r
\r
    def test_os_path_walk(self):\r
        msg = "In 3.x, os.path.walk is removed in favor of os.walk."\r
        def dumbo(where, names, args): pass\r
        for path_mod in ("ntpath", "macpath", "os2emxpath", "posixpath"):\r
            mod = __import__(path_mod)\r
            reset_module_registry(mod)\r
            with check_py3k_warnings() as w:\r
                mod.walk("crashers", dumbo, None)\r
            self.assertEqual(str(w.message), msg)\r
\r
    def test_reduce_move(self):\r
        from operator import add\r
        # reduce tests may have already triggered this warning\r
        reset_module_registry(unittest.case)\r
        with warnings.catch_warnings():\r
            warnings.filterwarnings("error", "reduce")\r
            self.assertRaises(DeprecationWarning, reduce, add, range(10))\r
\r
    def test_mutablestring_removal(self):\r
        # UserString.MutableString has been removed in 3.0.\r
        import UserString\r
        # UserString tests may have already triggered this warning\r
        reset_module_registry(UserString)\r
        with warnings.catch_warnings():\r
            warnings.filterwarnings("error", ".*MutableString",\r
                                    DeprecationWarning)\r
            self.assertRaises(DeprecationWarning, UserString.MutableString)\r
\r
\r
def test_main():\r
    run_unittest(TestPy3KWarnings,\r
                 TestStdlibRemovals)\r
\r
if __name__ == '__main__':\r
    test_main()\r