SylvainDe / DidYouMean-Python

    def test_import_star(self):

        """'import *' in nested functions."""

        # NICE_TO_HAVE

        codes = [

            "def func1():\n\tbar='1'\n\tdef func2():"

            "\n\t\tfrom math import *\n\t\tTrue\n\tfunc2()\nfunc1()",

            "def func1():\n\tfrom math import *"

            "\n\tdef func2():\n\t\tTrue",

        ]

        with warnings.catch_warnings():

            warnings.simplefilter("ignore", category=SyntaxWarning)

            for code in codes:

                self.throws(code, IMPORTSTAR, [])

    def test_unpack(self):

        """Extended tuple unpacking does not work prior to Python 3."""

        # NICE_TO_HAVE

        version = (3, 0)

        code = 'a, *b = (1, 2, 3)'

        self.throws(code, INVALIDSYNTAX, [], up_to_version(version))

        self.runs(code, from_version(version))

    def test_unpack2(self):

        """Unpacking in function arguments was supported up to Python 3."""

        # NICE_TO_HAVE

        version = (3, 0)

        """Some methods have been moved from string to str."""

        # NICE_TO_HAVE

        version1 = (3, 0)

        version2 = (3, 5)

        code = 'import string\n{0}.maketrans'

        code_str, code_string = format_str(code, 'str', 'string')

        code_str2 = 'str.maketrans'  # No 'string' import

        code_str3 = 'import string as my_string\nstr.maketrans'  # Named import

        self.throws(code_str, ATTRIBUTEERROR, [], up_to_version(version1))

        self.throws(code_str2, ATTRIBUTEERROR, [], up_to_version(version1))

        self.throws(code_str3, ATTRIBUTEERROR, [], up_to_version(version1))

        self.runs(code_string, up_to_version(version1))

        self.throws(code_string, ATTRIBUTEERROR, [], (version1, version2))

        self.throws(code_string, MODATTRIBUTEERROR, [], from_version(version2))

        self.runs(code_str, from_version(version1))

        self.runs(code_str2, from_version(version1))

        self.runs(code_str3, from_version(version1))

    def test_join(self):

        """Test what happens when join is used incorrectly.

        This can be frustrating to call join on an iterable instead of a

        string.

        """

        code = "['a', 'b'].join('-')"

        self.throws(code, ATTRIBUTEERROR, "'my_string.join(list)'")