RegexTests.test_invalid_token() - Code Metrics - Inspection of "Add a few tests about Python 3 features" - SylvainDe/DidYouMean-Python - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d801f1...c47997 )

by De

created 2016-10-06 17:04 UTC

RegexTests.test_invalid_token() A

↳ Parent: RegexTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
rs	10
cc	1

# -*- coding: utf-8
"""Unit tests for regexps from didyoumean_re.py."""
import unittest2
import didyoumean_re as re
import sys

NO_GROUP = ((), dict())


class RegexTests(unittest2.TestCase):
    """Tests to check that error messages match the regexps."""

    def re_matches(self, text, regexp, results):
        """Check that text matches regexp and gives the right match groups.

        result is a tuple containing the expected return values for groups()
        and groupdict().
        """
        groups, named_groups = results
        self.assertRegexpMatches(text, regexp)   # does pretty printing
        match = re.match(regexp, text)
        self.assertTrue(match)
        self.assertEqual(groups, match.groups())
        self.assertEqual(named_groups, match.groupdict())

    def test_unbound_assignment(self):
        """Test VARREFBEFOREASSIGN_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
            "local variable 'some_var' referenced before assignment",
            "free variable 'some_var' referenced before assignment " \
            "in enclosing scope",
        ]
        groups = ('some_var',)
        named_groups = {'name': 'some_var'}
        results = (groups, named_groups)
        for msg in msgs:
            self.re_matches(msg, re.VARREFBEFOREASSIGN_RE, results)

    def test_name_not_defined(self):
        """Test NAMENOTDEFINED_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy3
            "name 'some_name' is not defined",
            # Python 2.6/2.7/3.2/3.3/PyPy/PyPy3
            "global name 'some_name' is not defined",
        ]
        groups = ('some_name',)
        named_groups = {'name': 'some_name'}
        for msg in msgs:
            self.re_matches(msg, re.NAMENOTDEFINED_RE, (groups, named_groups))

    def test_attribute_error(self):
        """Test ATTRIBUTEERROR_RE."""
        group_msg = {
            ('some.class', 'attri'): [
                # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
                "'some.class' object has no attribute 'attri'",
            ],
            ('SomeClass', 'attri'): [
                # Python 2.6/2.7/PyPy
                "SomeClass instance has no attribute 'attri'",
                # Python 2.6/2.7
                "class SomeClass has no attribute 'attri'",
                # Python 3.2/3.3/3.4/3.5
                "type object 'SomeClass' has no attribute 'attri'",
            ],
        }
        for group, msgs in group_msg.items():
            for msg in msgs:
                self.re_matches(msg, re.ATTRIBUTEERROR_RE, (group, dict()))

    def test_module_attribute_error(self):
        """Test MODULEHASNOATTRIBUTE_RE."""
        # Python 3.5
        msg = "module 'some_module' has no attribute 'attri'"
        group = ('some_module', 'attri')
        self.re_matches(msg, re.MODULEHASNOATTRIBUTE_RE, (group, dict()))

    def test_cannot_import(self):
        """Test CANNOTIMPORT_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3
            "cannot import name pie",
            # Python 3.4/3.5/PyPy/PyPy3
            "cannot import name 'pie'",
        ]
        groups = ('pie',)
        for msg in msgs:
            self.re_matches(msg, re.CANNOTIMPORT_RE, (groups, dict()))

    def test_no_module_named(self):
        """Test NOMODULE_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/PyPy/PyPy3
            "No module named fake_module",
            # Python 3.3/3.4/3.5
            "No module named 'fake_module'",
        ]
        groups = ('fake_module',)
        for msg in msgs:
            self.re_matches(msg, re.NOMODULE_RE, (groups, dict()))

    def test_index_out_of_range(self):
        """Test INDEXOUTOFRANGE_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
        msg = "list index out of range"
        self.re_matches(msg, re.INDEXOUTOFRANGE_RE, NO_GROUP)

    def test_unsubscriptable(self):
        """Test UNSUBSCRIBTABLE_RE."""
        msgs = [
            # Python 2.6
            "'function' object is unsubscriptable",
            # Python 2.7
            "'function' object has no attribute '__getitem__'",
            # Python 3.2/3.3/3.4/3.5/PyPy/PyPy3
            "'function' object is not subscriptable",
        ]
        groups = ('function',)
        for msg in msgs:
            self.re_matches(msg, re.UNSUBSCRIBTABLE_RE, (groups, dict()))

    def test_unexpected_kw_arg(self):
        """Test UNEXPECTED_KEYWORDARG_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
        msg = "some_func() got an unexpected keyword argument 'a'"
        groups = ('some_func', 'a')
        self.re_matches(msg, re.UNEXPECTED_KEYWORDARG_RE, (groups, dict()))

    def test_unexpected_kw_arg2(self):
        """Test UNEXPECTED_KEYWORDARG2_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5
        msg = "'this_doesnt_exist' is an invalid " \
            "keyword argument for this function"
        groups = ('this_doesnt_exist', )
        self.re_matches(msg, re.UNEXPECTED_KEYWORDARG2_RE, (groups, dict()))

    def test_unexpected_kw_arg3(self):
        """Test UNEXPECTED_KEYWORDARG3_RE."""
        # PyPy/PyPy3
        msg = "invalid keyword arguments to print()"
        groups = ('print', )
        self.re_matches(msg, re.UNEXPECTED_KEYWORDARG3_RE, (groups, dict()))

    def test_zero_length_field(self):
        """Test ZERO_LEN_FIELD_RE."""
        # Python 2.6
        msg = "zero length field name in format"
        self.re_matches(msg, re.ZERO_LEN_FIELD_RE, NO_GROUP)

    def test_math_domain_error(self):
        """Test MATH_DOMAIN_ERROR_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
        msg = "math domain error"
        self.re_matches(msg, re.MATH_DOMAIN_ERROR_RE, NO_GROUP)

    def test_too_many_values(self):
        """Test TOO_MANY_VALUES_UNPACK_RE."""
        msgs = [
            # Python 2.6/2.7
            "too many values to unpack",
            # Python 3.2/3.3/3.4/3.5/PyPy3
            "too many values to unpack (expected 3)",
        ]
        for msg in msgs:
            self.re_matches(msg, re.TOO_MANY_VALUES_UNPACK_RE, NO_GROUP)

    def test_unhashable_type(self):
        """Test UNHASHABLE_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5
            "unhashable type: 'list'",
            # PyPy/PyPy3
            "'list' objects are unhashable",
        ]
        groups = ('list',)
        for msg in msgs:
            self.re_matches(msg, re.UNHASHABLE_RE, (groups, dict()))

    def test_outside_function(self):
        """Test OUTSIDE_FUNCTION_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
            "'return' outside function",
            # PyPy/PyPy3
            "return outside function",
        ]
        groups = ('return',)
        for msg in msgs:
            self.re_matches(msg, re.OUTSIDE_FUNCTION_RE, (groups, dict()))

    def test_nb_positional_argument(self):
        """Test NB_ARG_RE."""
        msgs = [
            # Python 2.6/2.7/PyPy/PyPy3
            "some_func() takes exactly 1 argument (2 given)",
            "some_func() takes exactly 3 arguments (1 given)",
            "some_func() takes no arguments (1 given)",
            # Python 3.2
            "some_func() takes exactly 1 positional argument (2 given)",
            # Python 3.3/3.4/3.5
            "some_func() takes 1 positional argument but 2 were given",
            "some_func() takes 0 positional arguments but 1 was given",
        ]
        groups = ('some_func',)
        for msg in msgs:
            self.re_matches(msg, re.NB_ARG_RE, (groups, dict()))

    def test_missing_positional_arg(self):
        """Test MISSING_POS_ARG_RE."""
        msgs = [
            # Python 3.3/3.4/3.5
            "some_func() missing 2 required positional arguments: "
            "'much' and 'args'",
            "some_func() missing 1 required positional argument: "
            "'much'",
        ]
        groups = ('some_func',)
        for msg in msgs:
            self.re_matches(msg, re.MISSING_POS_ARG_RE, (groups, dict()))

    def test_need_more_values_to_unpack(self):
        """Test NEED_MORE_VALUES_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5(?)/PyPy3
            "need more than 2 values to unpack",
            # Python 3.5
            "not enough values to unpack (expected 3, got 2)",
        ]
        for msg in msgs:
            self.re_matches(msg, re.NEED_MORE_VALUES_RE, NO_GROUP)

    def test_missing_parentheses(self):
        """Test MISSING_PARENT_RE."""
        # Python 3.4/3.5
        msg = "Missing parentheses in call to 'exec'"
        groups = ('exec',)
        self.re_matches(msg, re.MISSING_PARENT_RE, (groups, dict()))

    def test_invalid_literal(self):
        """Test INVALID_LITERAL_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
        msg = "invalid literal for int() with base 10: 'toto'"
        groups = ('int', 'toto')
        self.re_matches(msg, re.INVALID_LITERAL_RE, (groups, dict()))

    def test_invalid_syntax(self):
        """Test INVALID_SYNTAX_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy3
        msg = "invalid syntax"
        self.re_matches(msg, re.INVALID_SYNTAX_RE, NO_GROUP)

    def test_invalid_comp(self):
        """Test INVALID_COMP_RE."""
        # PyPy3
        msg = "invalid comparison"
        self.re_matches(msg, re.INVALID_COMP_RE, NO_GROUP)

    def test_expected_length(self):
        """Test EXPECTED_LENGTH_RE."""
        # PyPy
        msg = "expected length 3, got 2"
        groups = ('3', '2')
        self.re_matches(msg, re.EXPECTED_LENGTH_RE, (groups, dict()))

    def test_future_first(self):
        """Test FUTURE_FIRST_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5
            "from __future__ imports must occur at the beginning of the file",
            # PyPy/PyPy3
            "__future__ statements must appear at beginning of file",
        ]
        for msg in msgs:
            self.re_matches(msg, re.FUTURE_FIRST_RE, NO_GROUP)

    def test_future_feature_not_def(self):
        """Test FUTURE_FEATURE_NOT_DEF_RE."""
        # Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
        msg = "future feature divisio is not defined"
        groups = ('divisio',)
        self.re_matches(msg, re.FUTURE_FEATURE_NOT_DEF_RE, (groups, dict()))

    def test_result_has_too_many_items(self):
        """Test RESULT_TOO_MANY_ITEMS_RE."""
        # Python 2.6
        msg = "range() result has too many items"
        groups = ('range',)
        self.re_matches(msg, re.RESULT_TOO_MANY_ITEMS_RE, (groups, dict()))

    def test_unqualified_exec(self):
        """Test UNQUALIFIED_EXEC_RE."""
        msgs = [
            # Python 2.6
            "unqualified exec is not allowed in function 'func_name' "
            "it is a nested function",
            # Python 2.7
            "unqualified exec is not allowed in function 'func_name' "
            "because it is a nested function",
            # Python 2.6
            "unqualified exec is not allowed in function 'func_name' "
            "it contains a nested function with free variables",
            # Python 2.7
            "unqualified exec is not allowed in function 'func_name' "
            "because it contains a nested function with free variables",
        ]
        for msg in msgs:
            self.re_matches(msg, re.UNQUALIFIED_EXEC_RE, NO_GROUP)

    def test_import_star(self):
        """Test IMPORTSTAR_RE."""
        msgs = [
            # Python 2.6
            "import * is not allowed in function 'func_name' because it "
            "is contains a nested function with free variables",
            # Python 2.7
            "import * is not allowed in function 'func_name' because it "
            "contains a nested function with free variables",
            # Python 2.6
            "import * is not allowed in function 'func_name' because it "
            "is is a nested function",
            # Python 2.7
            "import * is not allowed in function 'func_name' because it "
            "is a nested function",
            # Python 3
            "import * only allowed at module level"
        ]
        for msg in msgs:
            self.re_matches(msg, re.IMPORTSTAR_RE, NO_GROUP)

    def test_does_not_support(self):
        """Test OBJ_DOES_NOT_SUPPORT_RE."""
        msg = "'range' object does not support item assignment"
        groups = ('range',)
        self.re_matches(msg, re.OBJ_DOES_NOT_SUPPORT_RE, (groups, dict()))

    def test_cant_convert(self):
        """Test CANT_CONVERT_RE."""
        msg = "Can't convert 'int' object to str implicitly"
        groups = ('int', 'str')
        self.re_matches(msg, re.CANT_CONVERT_RE, (groups, dict()))

    def test_must_be_type1_not_type2(self):
        """Test MUST_BE_TYPE1_NOT_TYPE2_RE."""
        msg = "must be str, not int"
        groups = ('str', 'int')
        self.re_matches(msg, re.MUST_BE_TYPE1_NOT_TYPE2_RE, (groups, dict()))

    def test_cannot_concat(self):
        """Test CANNOT_CONCAT_RE."""
        msg = "cannot concatenate 'str' and 'int' objects"
        groups = ('str', 'int')
        self.re_matches(msg, re.CANNOT_CONCAT_RE, (groups, dict()))

    def test_unsupported_operand(self):
        """Test UNSUPPORTED_OP_RE."""
        msg = "unsupported operand type(s) for +: 'int' and 'str'"
        groups = ('+', 'int', 'str')
        self.re_matches(msg, re.UNSUPPORTED_OP_RE, (groups, dict()))

    def test_not_callable(self):
        """Test NOT_CALLABLE_RE."""
        msg = "'list' object is not callable"
        groups = ('list',)
        self.re_matches(msg, re.NOT_CALLABLE_RE, (groups, dict()))

    def test_descriptor_requires(self):
        """Test DESCRIPT_REQUIRES_TYPE_RE."""
        msg = "descriptor 'add' requires a 'set' object but received a 'int'"
        groups = ('add', 'set', 'int')
        self.re_matches(
            msg, re.DESCRIPT_REQUIRES_TYPE_RE, (groups, dict()))

    def test_argument_not_iterable(self):
        """Test ARG_NOT_ITERABLE_RE."""
        msgs = [
            # Python 2.6/2.7/3.2/3.3/3.4/3.5
            "argument of type 'type' is not iterable",
            # PyPy/PyPy3
            "'type' object is not iterable"
        ]
        groups = ('type',)
        for msg in msgs:
            self.re_matches(msg, re.ARG_NOT_ITERABLE_RE, (groups, dict()))

    def test_must_be_called_with_instance(self):
        """Test MUST_BE_CALLED_WITH_INST_RE."""
        msg = "unbound method add() must be called with set " \
              "instance as first argument (got int instance instead)"
        groups = ('add', 'set', 'int')
        self.re_matches(
            msg, re.MUST_BE_CALLED_WITH_INST_RE, (groups, dict()))

    def test_object_has_no(self):
        """Test OBJECT_HAS_NO_FUNC_RE."""
        msgs = {
            # Python 2.6/2.7/3.2/3.3/3.4/3.5
            'len': "object of type 'generator' has no len()",
            # PyPy/PyPy3
            'length': "'generator' has no length",
        }
        for name, msg in msgs.items():
            groups = ('generator', name)
            self.re_matches(msg, re.OBJECT_HAS_NO_FUNC_RE, (groups, dict()))

    def test_nobinding_nonlocal(self):
        """Test NO_BINDING_NONLOCAL_RE."""
        msg = "no binding for nonlocal 'foo' found"
        groups = ('foo',)
        self.re_matches(msg, re.NO_BINDING_NONLOCAL_RE, (groups, dict()))

    def test_nosuchfile(self):
        """Test NO_SUCH_FILE_RE."""
        msg = "No such file or directory"
        self.re_matches(msg, re.NO_SUCH_FILE_RE, NO_GROUP)

    def test_timedata_does_not_match_format(self):
        """Test TIME_DATA_DOES_NOT_MATCH_FORMAT_RE."""
        msg = "time data '%d %b %y' does not match format '30 Nov 00'"
        # 'time data "%d \'%b %y" does not match format \'30 Nov 00\''
        groups = ("'%d %b %y'", "'30 Nov 00'")
        named_groups = {'format': "'30 Nov 00'", 'timedata': "'%d %b %y'"}
        self.re_matches(msg,
                        re.TIME_DATA_DOES_NOT_MATCH_FORMAT_RE,
                        (groups, named_groups))

    def test_invalid_token(self):
        """Test INVALID_TOKEN_RE."""
        msg = 'invalid token'
        self.re_matches(msg, re.INVALID_TOKEN_RE, NO_GROUP)

if __name__ == '__main__':
    print(sys.version_info)
    unittest2.main()


1			# -*- coding: utf-8
2			"""Unit tests for regexps from didyoumean_re.py."""
3			import unittest2
4			import didyoumean_re as re
5			import sys
6
7			NO_GROUP = ((), dict())
8
9
10			class RegexTests(unittest2.TestCase):
11			"""Tests to check that error messages match the regexps."""
12
13			def re_matches(self, text, regexp, results):
14			"""Check that text matches regexp and gives the right match groups.
15
16			result is a tuple containing the expected return values for groups()
17			and groupdict().
18			"""
19			groups, named_groups = results
20			self.assertRegexpMatches(text, regexp) # does pretty printing
21			match = re.match(regexp, text)
22			self.assertTrue(match)
23			self.assertEqual(groups, match.groups())
24			self.assertEqual(named_groups, match.groupdict())
25
26			def test_unbound_assignment(self):
27			"""Test VARREFBEFOREASSIGN_RE."""
28			msgs = [
29			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
30			"local variable 'some_var' referenced before assignment",
31			"free variable 'some_var' referenced before assignment " \
32			"in enclosing scope",
33			]
34			groups = ('some_var',)
35			named_groups = {'name': 'some_var'}
36			results = (groups, named_groups)
37			for msg in msgs:
38			self.re_matches(msg, re.VARREFBEFOREASSIGN_RE, results)
39
40			def test_name_not_defined(self):
41			"""Test NAMENOTDEFINED_RE."""
42			msgs = [
43			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy3
44			"name 'some_name' is not defined",
45			# Python 2.6/2.7/3.2/3.3/PyPy/PyPy3
46			"global name 'some_name' is not defined",
47			]
48			groups = ('some_name',)
49			named_groups = {'name': 'some_name'}
50			for msg in msgs:
51			self.re_matches(msg, re.NAMENOTDEFINED_RE, (groups, named_groups))
52
53			def test_attribute_error(self):
54			"""Test ATTRIBUTEERROR_RE."""
55			group_msg = {
56			('some.class', 'attri'): [
57			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
58			"'some.class' object has no attribute 'attri'",
59			],
60			('SomeClass', 'attri'): [
61			# Python 2.6/2.7/PyPy
62			"SomeClass instance has no attribute 'attri'",
63			# Python 2.6/2.7
64			"class SomeClass has no attribute 'attri'",
65			# Python 3.2/3.3/3.4/3.5
66			"type object 'SomeClass' has no attribute 'attri'",
67			],
68			}
69			for group, msgs in group_msg.items():
70			for msg in msgs:
71			self.re_matches(msg, re.ATTRIBUTEERROR_RE, (group, dict()))
72
73			def test_module_attribute_error(self):
74			"""Test MODULEHASNOATTRIBUTE_RE."""
75			# Python 3.5
76			msg = "module 'some_module' has no attribute 'attri'"
77			group = ('some_module', 'attri')
78			self.re_matches(msg, re.MODULEHASNOATTRIBUTE_RE, (group, dict()))
79
80			def test_cannot_import(self):
81			"""Test CANNOTIMPORT_RE."""
82			msgs = [
83			# Python 2.6/2.7/3.2/3.3
84			"cannot import name pie",
85			# Python 3.4/3.5/PyPy/PyPy3
86			"cannot import name 'pie'",
87			]
88			groups = ('pie',)
89			for msg in msgs:
90			self.re_matches(msg, re.CANNOTIMPORT_RE, (groups, dict()))
91
92			def test_no_module_named(self):
93			"""Test NOMODULE_RE."""
94			msgs = [
95			# Python 2.6/2.7/3.2/PyPy/PyPy3
96			"No module named fake_module",
97			# Python 3.3/3.4/3.5
98			"No module named 'fake_module'",
99			]
100			groups = ('fake_module',)
101			for msg in msgs:
102			self.re_matches(msg, re.NOMODULE_RE, (groups, dict()))
103
104			def test_index_out_of_range(self):
105			"""Test INDEXOUTOFRANGE_RE."""
106			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
107			msg = "list index out of range"
108			self.re_matches(msg, re.INDEXOUTOFRANGE_RE, NO_GROUP)
109
110			def test_unsubscriptable(self):
111			"""Test UNSUBSCRIBTABLE_RE."""
112			msgs = [
113			# Python 2.6
114			"'function' object is unsubscriptable",
115			# Python 2.7
116			"'function' object has no attribute '__getitem__'",
117			# Python 3.2/3.3/3.4/3.5/PyPy/PyPy3
118			"'function' object is not subscriptable",
119			]
120			groups = ('function',)
121			for msg in msgs:
122			self.re_matches(msg, re.UNSUBSCRIBTABLE_RE, (groups, dict()))
123
124			def test_unexpected_kw_arg(self):
125			"""Test UNEXPECTED_KEYWORDARG_RE."""
126			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
127			msg = "some_func() got an unexpected keyword argument 'a'"
128			groups = ('some_func', 'a')
129			self.re_matches(msg, re.UNEXPECTED_KEYWORDARG_RE, (groups, dict()))
130
131			def test_unexpected_kw_arg2(self):
132			"""Test UNEXPECTED_KEYWORDARG2_RE."""
133			# Python 2.6/2.7/3.2/3.3/3.4/3.5
134			msg = "'this_doesnt_exist' is an invalid " \
135			"keyword argument for this function"
136			groups = ('this_doesnt_exist', )
137			self.re_matches(msg, re.UNEXPECTED_KEYWORDARG2_RE, (groups, dict()))
138
139			def test_unexpected_kw_arg3(self):
140			"""Test UNEXPECTED_KEYWORDARG3_RE."""
141			# PyPy/PyPy3
142			msg = "invalid keyword arguments to print()"
143			groups = ('print', )
144			self.re_matches(msg, re.UNEXPECTED_KEYWORDARG3_RE, (groups, dict()))
145
146			def test_zero_length_field(self):
147			"""Test ZERO_LEN_FIELD_RE."""
148			# Python 2.6
149			msg = "zero length field name in format"
150			self.re_matches(msg, re.ZERO_LEN_FIELD_RE, NO_GROUP)
151
152			def test_math_domain_error(self):
153			"""Test MATH_DOMAIN_ERROR_RE."""
154			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
155			msg = "math domain error"
156			self.re_matches(msg, re.MATH_DOMAIN_ERROR_RE, NO_GROUP)
157
158			def test_too_many_values(self):
159			"""Test TOO_MANY_VALUES_UNPACK_RE."""
160			msgs = [
161			# Python 2.6/2.7
162			"too many values to unpack",
163			# Python 3.2/3.3/3.4/3.5/PyPy3
164			"too many values to unpack (expected 3)",
165			]
166			for msg in msgs:
167			self.re_matches(msg, re.TOO_MANY_VALUES_UNPACK_RE, NO_GROUP)
168
169			def test_unhashable_type(self):
170			"""Test UNHASHABLE_RE."""
171			msgs = [
172			# Python 2.6/2.7/3.2/3.3/3.4/3.5
173			"unhashable type: 'list'",
174			# PyPy/PyPy3
175			"'list' objects are unhashable",
176			]
177			groups = ('list',)
178			for msg in msgs:
179			self.re_matches(msg, re.UNHASHABLE_RE, (groups, dict()))
180
181			def test_outside_function(self):
182			"""Test OUTSIDE_FUNCTION_RE."""
183			msgs = [
184			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
185			"'return' outside function",
186			# PyPy/PyPy3
187			"return outside function",
188			]
189			groups = ('return',)
190			for msg in msgs:
191			self.re_matches(msg, re.OUTSIDE_FUNCTION_RE, (groups, dict()))
192
193			def test_nb_positional_argument(self):
194			"""Test NB_ARG_RE."""
195			msgs = [
196			# Python 2.6/2.7/PyPy/PyPy3
197			"some_func() takes exactly 1 argument (2 given)",
198			"some_func() takes exactly 3 arguments (1 given)",
199			"some_func() takes no arguments (1 given)",
200			# Python 3.2
201			"some_func() takes exactly 1 positional argument (2 given)",
202			# Python 3.3/3.4/3.5
203			"some_func() takes 1 positional argument but 2 were given",
204			"some_func() takes 0 positional arguments but 1 was given",
205			]
206			groups = ('some_func',)
207			for msg in msgs:
208			self.re_matches(msg, re.NB_ARG_RE, (groups, dict()))
209
210			def test_missing_positional_arg(self):
211			"""Test MISSING_POS_ARG_RE."""
212			msgs = [
213			# Python 3.3/3.4/3.5
214			"some_func() missing 2 required positional arguments: "
215			"'much' and 'args'",
216			"some_func() missing 1 required positional argument: "
217			"'much'",
218			]
219			groups = ('some_func',)
220			for msg in msgs:
221			self.re_matches(msg, re.MISSING_POS_ARG_RE, (groups, dict()))
222
223			def test_need_more_values_to_unpack(self):
224			"""Test NEED_MORE_VALUES_RE."""
225			msgs = [
226			# Python 2.6/2.7/3.2/3.3/3.4/3.5(?)/PyPy3
227			"need more than 2 values to unpack",
228			# Python 3.5
229			"not enough values to unpack (expected 3, got 2)",
230			]
231			for msg in msgs:
232			self.re_matches(msg, re.NEED_MORE_VALUES_RE, NO_GROUP)
233
234			def test_missing_parentheses(self):
235			"""Test MISSING_PARENT_RE."""
236			# Python 3.4/3.5
237			msg = "Missing parentheses in call to 'exec'"
238			groups = ('exec',)
239			self.re_matches(msg, re.MISSING_PARENT_RE, (groups, dict()))
240
241			def test_invalid_literal(self):
242			"""Test INVALID_LITERAL_RE."""
243			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
244			msg = "invalid literal for int() with base 10: 'toto'"
245			groups = ('int', 'toto')
246			self.re_matches(msg, re.INVALID_LITERAL_RE, (groups, dict()))
247
248			def test_invalid_syntax(self):
249			"""Test INVALID_SYNTAX_RE."""
250			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy3
251			msg = "invalid syntax"
252			self.re_matches(msg, re.INVALID_SYNTAX_RE, NO_GROUP)
253
254			def test_invalid_comp(self):
255			"""Test INVALID_COMP_RE."""
256			# PyPy3
257			msg = "invalid comparison"
258			self.re_matches(msg, re.INVALID_COMP_RE, NO_GROUP)
259
260			def test_expected_length(self):
261			"""Test EXPECTED_LENGTH_RE."""
262			# PyPy
263			msg = "expected length 3, got 2"
264			groups = ('3', '2')
265			self.re_matches(msg, re.EXPECTED_LENGTH_RE, (groups, dict()))
266
267			def test_future_first(self):
268			"""Test FUTURE_FIRST_RE."""
269			msgs = [
270			# Python 2.6/2.7/3.2/3.3/3.4/3.5
271			"from __future__ imports must occur at the beginning of the file",
272			# PyPy/PyPy3
273			"__future__ statements must appear at beginning of file",
274			]
275			for msg in msgs:
276			self.re_matches(msg, re.FUTURE_FIRST_RE, NO_GROUP)
277
278			def test_future_feature_not_def(self):
279			"""Test FUTURE_FEATURE_NOT_DEF_RE."""
280			# Python 2.6/2.7/3.2/3.3/3.4/3.5/PyPy/PyPy3
281			msg = "future feature divisio is not defined"
282			groups = ('divisio',)
283			self.re_matches(msg, re.FUTURE_FEATURE_NOT_DEF_RE, (groups, dict()))
284
285			def test_result_has_too_many_items(self):
286			"""Test RESULT_TOO_MANY_ITEMS_RE."""
287			# Python 2.6
288			msg = "range() result has too many items"
289			groups = ('range',)
290			self.re_matches(msg, re.RESULT_TOO_MANY_ITEMS_RE, (groups, dict()))
291
292			def test_unqualified_exec(self):
293			"""Test UNQUALIFIED_EXEC_RE."""
294			msgs = [
295			# Python 2.6
296			"unqualified exec is not allowed in function 'func_name' "
297			"it is a nested function",
298			# Python 2.7
299			"unqualified exec is not allowed in function 'func_name' "
300			"because it is a nested function",
301			# Python 2.6
302			"unqualified exec is not allowed in function 'func_name' "
303			"it contains a nested function with free variables",
304			# Python 2.7
305			"unqualified exec is not allowed in function 'func_name' "
306			"because it contains a nested function with free variables",
307			]
308			for msg in msgs:
309			self.re_matches(msg, re.UNQUALIFIED_EXEC_RE, NO_GROUP)
310
311			def test_import_star(self):
312			"""Test IMPORTSTAR_RE."""
313			msgs = [
314			# Python 2.6
315			"import * is not allowed in function 'func_name' because it "
316			"is contains a nested function with free variables",
317			# Python 2.7
318			"import * is not allowed in function 'func_name' because it "
319			"contains a nested function with free variables",
320			# Python 2.6
321			"import * is not allowed in function 'func_name' because it "
322			"is is a nested function",
323			# Python 2.7
324			"import * is not allowed in function 'func_name' because it "
325			"is a nested function",
326			# Python 3
327			"import * only allowed at module level"
328			]
329			for msg in msgs:
330			self.re_matches(msg, re.IMPORTSTAR_RE, NO_GROUP)
331
332			def test_does_not_support(self):
333			"""Test OBJ_DOES_NOT_SUPPORT_RE."""
334			msg = "'range' object does not support item assignment"
335			groups = ('range',)
336			self.re_matches(msg, re.OBJ_DOES_NOT_SUPPORT_RE, (groups, dict()))
337
338			def test_cant_convert(self):
339			"""Test CANT_CONVERT_RE."""
340			msg = "Can't convert 'int' object to str implicitly"
341			groups = ('int', 'str')
342			self.re_matches(msg, re.CANT_CONVERT_RE, (groups, dict()))
343
344			def test_must_be_type1_not_type2(self):
345			"""Test MUST_BE_TYPE1_NOT_TYPE2_RE."""
346			msg = "must be str, not int"
347			groups = ('str', 'int')
348			self.re_matches(msg, re.MUST_BE_TYPE1_NOT_TYPE2_RE, (groups, dict()))
349
350			def test_cannot_concat(self):
351			"""Test CANNOT_CONCAT_RE."""
352			msg = "cannot concatenate 'str' and 'int' objects"
353			groups = ('str', 'int')
354			self.re_matches(msg, re.CANNOT_CONCAT_RE, (groups, dict()))
355
356			def test_unsupported_operand(self):
357			"""Test UNSUPPORTED_OP_RE."""
358			msg = "unsupported operand type(s) for +: 'int' and 'str'"
359			groups = ('+', 'int', 'str')
360			self.re_matches(msg, re.UNSUPPORTED_OP_RE, (groups, dict()))
361
362			def test_not_callable(self):
363			"""Test NOT_CALLABLE_RE."""
364			msg = "'list' object is not callable"
365			groups = ('list',)
366			self.re_matches(msg, re.NOT_CALLABLE_RE, (groups, dict()))
367
368			def test_descriptor_requires(self):
369			"""Test DESCRIPT_REQUIRES_TYPE_RE."""
370			msg = "descriptor 'add' requires a 'set' object but received a 'int'"
371			groups = ('add', 'set', 'int')
372			self.re_matches(
373			msg, re.DESCRIPT_REQUIRES_TYPE_RE, (groups, dict()))
374
375			def test_argument_not_iterable(self):
376			"""Test ARG_NOT_ITERABLE_RE."""
377			msgs = [
378			# Python 2.6/2.7/3.2/3.3/3.4/3.5
379			"argument of type 'type' is not iterable",
380			# PyPy/PyPy3
381			"'type' object is not iterable"
382			]
383			groups = ('type',)
384			for msg in msgs:
385			self.re_matches(msg, re.ARG_NOT_ITERABLE_RE, (groups, dict()))
386
387			def test_must_be_called_with_instance(self):
388			"""Test MUST_BE_CALLED_WITH_INST_RE."""
389			msg = "unbound method add() must be called with set " \
390			"instance as first argument (got int instance instead)"
391			groups = ('add', 'set', 'int')
392			self.re_matches(
393			msg, re.MUST_BE_CALLED_WITH_INST_RE, (groups, dict()))
394
395			def test_object_has_no(self):
396			"""Test OBJECT_HAS_NO_FUNC_RE."""
397			msgs = {
398			# Python 2.6/2.7/3.2/3.3/3.4/3.5
399			'len': "object of type 'generator' has no len()",
400			# PyPy/PyPy3
401			'length': "'generator' has no length",
402			}
403			for name, msg in msgs.items():
404			groups = ('generator', name)
405			self.re_matches(msg, re.OBJECT_HAS_NO_FUNC_RE, (groups, dict()))
406
407			def test_nobinding_nonlocal(self):
408			"""Test NO_BINDING_NONLOCAL_RE."""
409			msg = "no binding for nonlocal 'foo' found"
410			groups = ('foo',)
411			self.re_matches(msg, re.NO_BINDING_NONLOCAL_RE, (groups, dict()))
412
413			def test_nosuchfile(self):
414			"""Test NO_SUCH_FILE_RE."""
415			msg = "No such file or directory"
416			self.re_matches(msg, re.NO_SUCH_FILE_RE, NO_GROUP)
417
418			def test_timedata_does_not_match_format(self):
419			"""Test TIME_DATA_DOES_NOT_MATCH_FORMAT_RE."""
420			msg = "time data '%d %b %y' does not match format '30 Nov 00'"
421			# 'time data "%d \'%b %y" does not match format \'30 Nov 00\''
422			groups = ("'%d %b %y'", "'30 Nov 00'")
423			named_groups = {'format': "'30 Nov 00'", 'timedata': "'%d %b %y'"}
424			self.re_matches(msg,
425			re.TIME_DATA_DOES_NOT_MATCH_FORMAT_RE,
426			(groups, named_groups))
427
428			def test_invalid_token(self):
429			"""Test INVALID_TOKEN_RE."""
430			msg = 'invalid token'
431			self.re_matches(msg, re.INVALID_TOKEN_RE, NO_GROUP)
432
433			if __name__ == '__main__':
434			print(sys.version_info)
435			unittest2.main()
436

SylvainDe / DidYouMean-Python

Push — master ( d801f1...c47997 )

RegexTests.test_invalid_token() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like