Add files using upload-large-folder tool

testbed/pylint-dev__pylint/tests/functional/ext/bad_builtin/bad_builtin_extension.py

@@ -0,0 +1,4 @@
+# pylint: disable=missing-docstring
+
+TEST = map(str, (1, 2, 3)) # [bad-builtin]
+TEST1 = filter(str, (1, 2, 3)) # [bad-builtin]

testbed/pylint-dev__pylint/tests/functional/ext/bad_builtin/bad_builtin_extension.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.bad_builtin,

testbed/pylint-dev__pylint/tests/functional/ext/bad_builtin/bad_builtin_extension.txt

@@ -0,0 +1,2 @@
+bad-builtin:3:7:3:26::Used builtin function 'map'. Using a list comprehension can be clearer.:UNDEFINED
+bad-builtin:4:8:4:30::Used builtin function 'filter'. Using a list comprehension can be clearer.:UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/bad_builtin/bad_builtins.py

@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+input("Yes or no ? (Y=1, n=0)")  # [bad-builtin]
+print(map(str, filter(1, [1, 2, 3])))  # [bad-builtin, bad-builtin, bad-builtin]

testbed/pylint-dev__pylint/tests/functional/ext/bad_builtin/bad_builtins.rc

@@ -0,0 +1,5 @@
+[MAIN]
+load-plugins = pylint.extensions.bad_builtin
+
+[pylint.DEPRECATED_BUILTINS]
+bad-functions=map,input,filter,print

testbed/pylint-dev__pylint/tests/functional/ext/bad_builtin/bad_builtins.txt

@@ -0,0 +1,4 @@
+bad-builtin:2:0:2:31::Used builtin function 'input':UNDEFINED
+bad-builtin:3:15:3:35::Used builtin function 'filter'. Using a list comprehension can be clearer.:UNDEFINED
+bad-builtin:3:6:3:36::Used builtin function 'map'. Using a list comprehension can be clearer.:UNDEFINED
+bad-builtin:3:0:3:37::Used builtin function 'print':UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/broad_try_clause/broad_try_clause_extension.py

@@ -0,0 +1,49 @@
+# pylint: disable=missing-docstring, invalid-name
+
+MY_DICTIONARY = {"key_one": 1, "key_two": 2, "key_three": 3}
+
+try:  # [too-many-try-statements]
+    value = MY_DICTIONARY["key_one"]
+    value += 1
+    print("This one has an except clause only.")
+except KeyError:
+    pass
+
+try:  # [too-many-try-statements]
+    value = MY_DICTIONARY["key_one"]
+    value += 1
+    print("This one has a finally clause only.")
+finally:
+    pass
+
+try:  # [too-many-try-statements]
+    value = MY_DICTIONARY["key_one"]
+    value += 1
+    print("This one has an except clause...")
+    print("and also a finally clause!")
+except KeyError:
+    pass
+finally:
+    pass
+
+try:  # [too-many-try-statements]
+    if "key_one" in MY_DICTIONARY:
+        entered_if_body = True
+        print("This verifies that content inside of an if statement is counted too.")
+    else:
+        entered_if_body = False
+
+    while False:
+        print("This verifies that content inside of a while loop is counted too.")
+
+    for item in []:
+        print("This verifies that content inside of a for loop is counted too.")
+
+
+except KeyError:
+    pass
+
+try:
+    value = MY_DICTIONARY["key_one"]
+except KeyError:
+    value = 0

testbed/pylint-dev__pylint/tests/functional/ext/broad_try_clause/broad_try_clause_extension.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.broad_try_clause,

testbed/pylint-dev__pylint/tests/functional/ext/broad_try_clause/broad_try_clause_extension.txt

@@ -0,0 +1,4 @@
+too-many-try-statements:5:0:10:8::try clause contains 3 statements, expected at most 1:UNDEFINED
+too-many-try-statements:12:0:17:8::try clause contains 3 statements, expected at most 1:UNDEFINED
+too-many-try-statements:19:0:25:8::try clause contains 4 statements, expected at most 1:UNDEFINED
+too-many-try-statements:29:0:44:8::try clause contains 7 statements, expected at most 1:UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/check_elif/check_elif.py

@@ -0,0 +1,48 @@
+# pylint: disable=no-else-raise,unsupported-membership-test,using-constant-test, comparison-of-constants
+
+"""Checks use of "else if" triggers a refactor message"""
+from typing import Union, Sequence, Any, Mapping
+
+
+def my_function():
+    """docstring"""
+    myint = 2
+    if myint > 5:
+        pass
+    else:
+        if myint <= 5:  # [else-if-used]
+            pass
+        else:
+            myint = 3
+            if myint > 2:
+                if myint > 3:
+                    pass
+                elif myint == 3:
+                    pass
+                elif myint < 3:
+                    pass
+                else:
+                    if myint:  # [else-if-used]
+                        pass
+            else:
+                if myint:
+                    pass
+                myint = 4
+
+
+def _if_in_fstring_comprehension_with_elif(
+    params: Union[Sequence[Any], Mapping[str, Any]]
+):
+    order = {}
+    if "z" not in "false":
+        raise TypeError(
+            f" {', '.join(sorted(i for i in order or () if i not in params))}"
+        )
+    elif "z" not in "true":
+        pass
+    else:
+        if "t" not in "false":  # [else-if-used]
+            raise TypeError("d")
+        else:
+            if "y" in "life":  # [else-if-used]
+                print("e")

testbed/pylint-dev__pylint/tests/functional/ext/check_elif/check_elif.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.check_elif,

testbed/pylint-dev__pylint/tests/functional/ext/check_elif/check_elif.txt

@@ -0,0 +1,4 @@
+else-if-used:13:8:30:25:my_function:"Consider using ""elif"" instead of ""else"" then ""if"" to remove one indentation level":HIGH
+else-if-used:25:20:26:28:my_function:"Consider using ""elif"" instead of ""else"" then ""if"" to remove one indentation level":HIGH
+else-if-used:44:8:48:26:_if_in_fstring_comprehension_with_elif:"Consider using ""elif"" instead of ""else"" then ""if"" to remove one indentation level":HIGH
+else-if-used:47:12:48:26:_if_in_fstring_comprehension_with_elif:"Consider using ""elif"" instead of ""else"" then ""if"" to remove one indentation level":HIGH

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_assignment_expr.py

@@ -0,0 +1,159 @@
+# pylint: disable=missing-docstring,invalid-name,undefined-variable,too-few-public-methods
+
+a1 = 2
+if a1:  # [consider-using-assignment-expr]
+    ...
+
+# Do not suggest assignment expressions if assignment spans multiple lines
+a2 = (
+    1,
+)
+if a2:
+    ...
+
+# Only first name should be replaced
+a3 = 2
+if a3 == a3_a:  # [consider-using-assignment-expr]
+    ...
+
+# Above black line length
+a4 = some_loooooooonnnnnngggg_object_name.with_some_really_long_function_name(arg)
+if a4:
+    ...
+
+def func_a():
+    a5 = some___object.function_name_is_just_long_enough_to_fit_in_line()  # some comment
+    if a5 is None:  # [consider-using-assignment-expr]
+        ...
+
+    # Using assignment expression would result in line being 89 chars long
+    a6 = some_long_object.function_name_is_too_long_enough_to_fit___line()
+    if a6 is None:
+        ...
+
+# Previous unrelate note should not match
+print("")
+if a7:
+    ...
+
+
+b1: int = 2
+if b1:  # [consider-using-assignment-expr]
+    ...
+
+b2 = some_function(2, 3)
+if b2:  # [consider-using-assignment-expr]
+    ...
+
+b3 = some_object.variable
+if b3:  # [consider-using-assignment-expr]
+    ...
+
+
+# UnaryOp
+c1 = 2
+if not c1:  # [consider-using-assignment-expr]
+    ...
+
+
+# Compare
+d1 = 2
+if d1 is True:  # [consider-using-assignment-expr]
+    ...
+
+d2 = 2
+if d2 is not None:  # [consider-using-assignment-expr]
+    ...
+
+d3 = 2
+if d3 == 2:  # [consider-using-assignment-expr]
+    ...
+
+
+# -----
+# Don't emit warning if match statement would be a better fit
+o1 = 2
+if o1 == 1:
+    ...
+elif o1 == 2:
+    ...
+elif o1 == 3:
+    ...
+
+o2 = 2
+if o2 == 1:
+    ...
+elif o2:
+    ...
+
+o3 = 2
+if o3 == 1:  # [consider-using-assignment-expr]
+    ...
+else:
+    ...
+
+o4 = 2
+if o4 == 1:  # [consider-using-assignment-expr]
+    ...
+elif o4 and o4_other:
+    ...
+
+o5 = 2
+if o5 == 1:  # [consider-using-assignment-expr]
+    ...
+elif o5_other == 1:
+    ...
+
+o6 = 2
+if o6 == 1:  # [consider-using-assignment-expr]
+    ...
+elif o6_other:
+    ...
+
+def func_p():
+    p1 = 2
+    if p1 == 1:
+        return
+    if p1 == 2:
+        return
+
+    p2 = 2
+    if p2 == 1:
+        return
+    if p2:
+        return
+
+    p3 = 2
+    if p3 == 1:  # [consider-using-assignment-expr]
+        ...
+    else:
+        ...
+
+    p4 = 2
+    if p4 == 1:  # [consider-using-assignment-expr]
+        ...
+    elif p4 and p4_other:
+        ...
+
+    p5 = 2
+    if p5 == 1:  # [consider-using-assignment-expr]
+        ...
+    elif p5_other == 1:
+        ...
+
+    p6 = 2
+    if p6 == 1:  # [consider-using-assignment-expr]
+        ...
+    elif p6_other:
+        ...
+
+
+# -----
+# Assignment expression does NOT work for attribute access
+# Make sure not to emit message!
+class A:
+    var = 1
+
+A.var = 2
+if A.var:
+    ...

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_assignment_expr.rc

@@ -0,0 +1,6 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style
+py-version=3.8
+
+[CODE_STYLE]
+max-line-length-suggestions=88

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_assignment_expr.txt

@@ -0,0 +1,18 @@
+consider-using-assignment-expr:4:3:4:5::"Use 'if (a1 := 2):' instead":UNDEFINED
+consider-using-assignment-expr:16:3:16:5::"Use 'if (a3 := 2) == a3_a:' instead":UNDEFINED
+consider-using-assignment-expr:26:7:26:9:func_a:"Use 'if (a5 := some___object.function_name_is_just_long_enough_to_fit_in_line()) is None:' instead":UNDEFINED
+consider-using-assignment-expr:41:3:41:5::"Use 'if (b1 := 2):' instead":UNDEFINED
+consider-using-assignment-expr:45:3:45:5::"Use 'if (b2 := some_function(2, 3)):' instead":UNDEFINED
+consider-using-assignment-expr:49:3:49:5::"Use 'if (b3 := some_object.variable):' instead":UNDEFINED
+consider-using-assignment-expr:55:7:55:9::"Use 'if not (c1 := 2):' instead":UNDEFINED
+consider-using-assignment-expr:61:3:61:5::"Use 'if (d1 := 2) is True:' instead":UNDEFINED
+consider-using-assignment-expr:65:3:65:5::"Use 'if (d2 := 2) is not None:' instead":UNDEFINED
+consider-using-assignment-expr:69:3:69:5::"Use 'if (d3 := 2) == 2:' instead":UNDEFINED
+consider-using-assignment-expr:90:3:90:5::"Use 'if (o3 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:96:3:96:5::"Use 'if (o4 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:102:3:102:5::"Use 'if (o5 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:108:3:108:5::"Use 'if (o6 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:127:7:127:9:func_p:"Use 'if (p3 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:133:7:133:9:func_p:"Use 'if (p4 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:139:7:139:9:func_p:"Use 'if (p5 := 2) == 1:' instead":UNDEFINED
+consider-using-assignment-expr:145:7:145:9:func_p:"Use 'if (p6 := 2) == 1:' instead":UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_augmented_assign.py

@@ -0,0 +1,135 @@
+"""Tests for consider-using-augmented-assign."""
+
+# pylint: disable=invalid-name,too-few-public-methods,import-error,consider-using-f-string,missing-docstring
+
+from unknown import Unknown
+
+x = 1
+
+# summation is commutative (for integer and float, but not for string)
+x = x + 3  # [consider-using-augmented-assign]
+x = 3 + x  # [consider-using-augmented-assign]
+x = x + "3"  # [consider-using-augmented-assign]
+x = "3" + x
+
+# We don't warn on intricate expressions as we lack knowledge of simplifying such
+# expressions which is necessary to see if they can become augmented
+x, y = 1 + x, 2 + x
+x = 1 + x - 2
+x = 1 + x + 2
+
+# For anything other than a float or an int we only want to warn on
+# assignments where the 'itself' is on the left side of the assignment
+my_list = [2, 3, 4]
+my_list = [1] + my_list
+
+
+class MyClass:
+    """Simple base class."""
+
+    def __init__(self) -> None:
+        self.x = 1
+        self.x = self.x + 1  # [consider-using-augmented-assign]
+        self.x = 1 + self.x  # [consider-using-augmented-assign]
+
+        x = 1  # [redefined-outer-name]
+        self.x = x
+
+
+instance = MyClass()
+
+x = instance.x + 1
+
+my_str = ""
+my_str = my_str + "foo"  # [consider-using-augmented-assign]
+my_str = "foo" + my_str
+
+my_bytes = b""
+my_bytes = my_bytes + b"foo"  # [consider-using-augmented-assign]
+my_bytes = b"foo" + my_bytes
+
+
+def return_str() -> str:
+    """Return a string."""
+    return ""
+
+
+# Currently we disregard all calls
+my_str = return_str() + my_str
+my_str = my_str % return_str()
+my_str = my_str % 1  # [consider-using-augmented-assign]
+my_str = my_str % (1, 2)  # [consider-using-augmented-assign]
+my_str = "%s" % my_str
+my_str = return_str() % my_str
+my_str = Unknown % my_str
+my_str = my_str % Unknown  # [consider-using-augmented-assign]
+
+# subtraction is anti-commutative
+x = x - 3  # [consider-using-augmented-assign]
+x = 3 - x
+
+# multiplication is commutative
+x = x * 3  # [consider-using-augmented-assign]
+x = 3 * x  # [consider-using-augmented-assign]
+
+# division is not commutative
+x = x / 3  # [consider-using-augmented-assign]
+x = 3 / x
+
+# integer division is not commutative
+x = x // 3  # [consider-using-augmented-assign]
+x = 3 // x
+
+# Left shift operator is not commutative
+x = x << 3  # [consider-using-augmented-assign]
+x = 3 << x
+
+# Right shift operator is not commutative
+x = x >> 3  # [consider-using-augmented-assign]
+x = 3 >> x
+
+# modulo is not commutative
+x = x % 3  # [consider-using-augmented-assign]
+x = 3 % x
+
+# exponential is not commutative
+x = x**3  # [consider-using-augmented-assign]
+x = 3**x
+
+# XOR is commutative
+x = x ^ 3  # [consider-using-augmented-assign]
+x = 3 ^ x  # [consider-using-augmented-assign]
+
+# Bitwise AND operator is commutative
+x = x & 3  # [consider-using-augmented-assign]
+x = 3 & x  # [consider-using-augmented-assign]
+
+# Bitwise OR operator is commutative
+x = x | 3  # [consider-using-augmented-assign]
+x = 3 | x  # [consider-using-augmented-assign]
+
+x = x > 3
+x = 3 > x
+
+x = x < 3
+x = 3 < x
+
+x = x >= 3
+x = 3 >= x
+
+x = x <= 3
+x = 3 <= x
+
+
+# https://github.com/PyCQA/pylint/issues/8086
+# consider-using-augmented-assign should only be flagged
+# if names attribute names match exactly.
+
+class A:
+    def __init__(self) -> None:
+        self.a = 1
+        self.b = A()
+
+    def test(self) -> None:
+        self.a = self.a + 1  # [consider-using-augmented-assign]
+        self.b.a = self.a + 1  # Names don't match!

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_augmented_assign.rc

@@ -0,0 +1,3 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style
+enable=consider-using-augmented-assign

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_augmented_assign.txt

@@ -0,0 +1,27 @@
+consider-using-augmented-assign:10:0:10:9::Use '+=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:11:0:11:9::Use '+=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:12:0:12:11::Use '+=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:32:8:32:27:MyClass.__init__:Use '+=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:33:8:33:27:MyClass.__init__:Use '+=' to do an augmented assign directly:INFERENCE
+redefined-outer-name:35:8:35:9:MyClass.__init__:Redefining name 'x' from outer scope (line 7):UNDEFINED
+consider-using-augmented-assign:44:0:44:23::Use '+=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:48:0:48:28::Use '+=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:60:0:60:19::Use '%=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:61:0:61:24::Use '%=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:65:0:65:25::Use '%=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:68:0:68:9::Use '-=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:72:0:72:9::Use '*=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:73:0:73:9::Use '*=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:76:0:76:9::Use '/=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:80:0:80:10::Use '//=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:84:0:84:10::Use '<<=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:88:0:88:10::Use '>>=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:92:0:92:9::Use '%=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:96:0:96:8::Use '**=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:100:0:100:9::Use '^=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:101:0:101:9::Use '^=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:104:0:104:9::Use '&=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:105:0:105:9::Use '&=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:108:0:108:9::Use '|=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:109:0:109:9::Use '|=' to do an augmented assign directly:INFERENCE
+consider-using-augmented-assign:134:8:134:27:A.test:Use '+=' to do an augmented assign directly:INFERENCE

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_namedtuple_or_dataclass.py

@@ -0,0 +1,79 @@
+# pylint: disable=missing-docstring,too-few-public-methods,unused-variable,no-name-in-module
+from typing import Final
+
+class Foo:
+    BAR = "bar"
+
+KEY_3 = "key_3"
+
+
+# Subdicts have at least 1 common key
+MAPPING_1 = {  # [consider-using-namedtuple-or-dataclass]
+    "entry_1": {"key_1": 0, "key_2": 1, "key_diff_1": 2},
+    "entry_2": {"key_1": 0, "key_2": 1, "key_diff_2": 3},
+}
+MAPPING_2 = {  # [consider-using-namedtuple-or-dataclass]
+    "entry_1": {KEY_3: None, Foo.BAR: None},
+    "entry_2": {KEY_3: None, Foo.BAR: None},
+}
+
+# ints are not valid fieldnames for namedtuples
+MAPPING_3 = {
+    "entry_1": {0: None, 1: None},
+    "entry_2": {0: None, 1: None},
+}
+
+# Subdicts have no common keys
+MAPPING_4 = {
+    "entry_1": {"key_3": 0, "key_4": 1, "key_diff_1": 2},
+    "entry_2": {"key_1": 0, "key_2": 1, "key_diff_2": 3},
+}
+
+def func():
+    # Not in module scope
+    mapping_4 = {
+        "entry_1": {"key_1": 0, "key_2": 1},
+        "entry_2": {"key_1": 0, "key_2": 1},
+    }
+
+    mapping_5: Final = {  # [consider-using-namedtuple-or-dataclass]
+        "entry_1": {"key_1": 0, "key_2": 1},
+        "entry_2": {"key_1": 0, "key_2": 1},
+    }
+
+
+# lists must have the same length
+MAPPING_6 = {  # [consider-using-namedtuple-or-dataclass]
+    "entry_1": [1, "a", set()],
+    "entry_2": [2, "b", set()],
+}
+MAPPING_7 = {
+    "entry_1": [],
+    "entry_2": [],
+}
+MAPPING_8 = {
+    "entry_1": [1],
+    "entry_2": [2, "b"],
+}
+MAPPING_9 = {  # [consider-using-namedtuple-or-dataclass]
+    "entry_1": (1, "a"),
+    "entry_2": (2, "b"),
+}
+
+# No entry can't contain only dicts
+MAPPING_10 = {
+    "entry_1": [
+        {"key_1": None, "key_2": None},
+    ],
+    "entry_2": [None]
+}
+
+# No either dict, tuple, or list as dict values
+MAPPING_11 = {
+    "entry_1": 1,
+    "entry_2": 2,
+}
+MAPPING_12 = {
+    "entry_1": "",
+    "entry_2": "",
+}

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_namedtuple_or_dataclass.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_namedtuple_or_dataclass.txt

@@ -0,0 +1,5 @@
+consider-using-namedtuple-or-dataclass:11:12:14:1::Consider using namedtuple or dataclass for dictionary values:UNDEFINED
+consider-using-namedtuple-or-dataclass:15:12:18:1::Consider using namedtuple or dataclass for dictionary values:UNDEFINED
+consider-using-namedtuple-or-dataclass:39:23:42:5:func:Consider using namedtuple or dataclass for dictionary values:UNDEFINED
+consider-using-namedtuple-or-dataclass:46:12:49:1::Consider using namedtuple or dataclass for dictionary values:UNDEFINED
+consider-using-namedtuple-or-dataclass:58:12:61:1::Consider using namedtuple or dataclass for dictionary values:UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_tuple.py

@@ -0,0 +1,31 @@
+# pylint: disable=invalid-name,missing-docstring,pointless-statement,unnecessary-comprehension
+
+var = (1, 2, 3)
+
+for x in var:
+    pass
+for x in (1, 2, 3):
+    pass
+for x in [1, 2, 3]:  # [consider-using-tuple]
+    pass
+
+(x for x in var)
+(x for x in (1, 2, 3))
+(x for x in [1, 2, 3])  # [consider-using-tuple]
+
+[x for x in var]
+[x for x in (1, 2, 3)]
+[x for x in [1, 2, 3]]  # [consider-using-tuple]
+
+
+for x in [*var]:  # [consider-using-tuple]
+    pass
+for x in [2, *var]:  # [consider-using-tuple]
+    pass
+
+[x for x in [*var, 2]]  # [consider-using-tuple]
+
+
+# Don't emit warning for sets as this is handled by builtin checker
+(x for x in {1, 2, 3})  # [use-sequence-for-iteration]
+[x for x in {*var, 2}]

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_tuple.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_consider_using_tuple.txt

@@ -0,0 +1,7 @@
+consider-using-tuple:9:9:9:18::Consider using an in-place tuple instead of list:UNDEFINED
+consider-using-tuple:14:12:14:21::Consider using an in-place tuple instead of list:UNDEFINED
+consider-using-tuple:18:12:18:21::Consider using an in-place tuple instead of list:UNDEFINED
+consider-using-tuple:21:9:21:15::Consider using an in-place tuple instead of list:UNDEFINED
+consider-using-tuple:23:9:23:18::Consider using an in-place tuple instead of list:UNDEFINED
+consider-using-tuple:26:12:26:21::Consider using an in-place tuple instead of list:UNDEFINED
+use-sequence-for-iteration:30:12:30:21::Use a sequence type when iterating over values:HIGH

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_default.py

@@ -0,0 +1,6 @@
+"""Test default configuration for code-style checker."""
+# pylint: disable=invalid-name
+
+# consider-using-augmented-assign is disabled by default
+x = 1
+x = x + 1

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_default.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_py_version_35.py

@@ -0,0 +1,7 @@
+"""No warnings should be emitted for features that require Python > 3.5"""
+# pylint: disable=invalid-name
+
+# consider-using-assignment-expr -> requires Python 3.8
+a1 = 2
+if a1:
+    ...

testbed/pylint-dev__pylint/tests/functional/ext/code_style/cs_py_version_35.rc

@@ -0,0 +1,3 @@
+[MAIN]
+load-plugins=pylint.extensions.code_style
+py-version=3.5

testbed/pylint-dev__pylint/tests/functional/ext/comparison_placement/misplaced_comparison_constant.py

@@ -0,0 +1,50 @@
+"""Check that the constants are on the right side of the comparisons"""
+
+# pylint: disable=singleton-comparison, missing-docstring, too-few-public-methods
+# pylint: disable=comparison-of-constants
+
+class MyClass:
+    def __init__(self):
+        self.attr = 1
+
+    def dummy_return(self):
+        return self.attr
+
+def dummy_return():
+    return 2
+
+def bad_comparisons():
+    """this is not ok"""
+    instance = MyClass()
+    for i in range(10):
+        if 5 <= i:  # [misplaced-comparison-constant]
+            pass
+        if 1 == i:  # [misplaced-comparison-constant]
+            pass
+        if 3 < dummy_return():  # [misplaced-comparison-constant]
+            pass
+        if 4 != instance.dummy_return():  # [misplaced-comparison-constant]
+            pass
+        if 1 == instance.attr:  # [misplaced-comparison-constant]
+            pass
+        if "aaa" == instance.attr: # [misplaced-comparison-constant]
+            pass
+
+def good_comparison():
+    """this is ok"""
+    for i in range(10):
+        if i == 5:
+            pass
+
+def double_comparison():
+    """Check that we return early for non-binary comparison"""
+    for i in range(10):
+        if i == 1 == 2:
+            pass
+        if 2 <= i <= 8:
+            print("Between 2 and 8 inclusive")
+
+def const_comparison():
+    """Check that we return early for comparison of two constants"""
+    if 1 == 2:
+        pass

testbed/pylint-dev__pylint/tests/functional/ext/comparison_placement/misplaced_comparison_constant.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.comparison_placement,

testbed/pylint-dev__pylint/tests/functional/ext/comparison_placement/misplaced_comparison_constant.txt

@@ -0,0 +1,6 @@
+misplaced-comparison-constant:20:11:20:17:bad_comparisons:Comparison should be i >= 5:UNDEFINED
+misplaced-comparison-constant:22:11:22:17:bad_comparisons:Comparison should be i == 1:UNDEFINED
+misplaced-comparison-constant:24:11:24:29:bad_comparisons:Comparison should be dummy_return() > 3:UNDEFINED
+misplaced-comparison-constant:26:11:26:39:bad_comparisons:Comparison should be instance.dummy_return() != 4:UNDEFINED
+misplaced-comparison-constant:28:11:28:29:bad_comparisons:Comparison should be instance.attr == 1:UNDEFINED
+misplaced-comparison-constant:30:11:30:33:bad_comparisons:Comparison should be instance.attr == 'aaa':UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/confusing_elif/confusing_elif.py

@@ -0,0 +1,143 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring
+
+
+def triggered_if_if_block_ends_with_elif(machine, old_conf, new_conf):
+    """Example code that will trigger the message
+
+    Given an if-elif construct
+    When the body of the if ends with an elif
+    Then the message confusing-consecutive-elif must be triggered.
+    """
+    if old_conf:
+        if not new_conf:
+            machine.disable()
+        elif old_conf.value != new_conf.value:
+            machine.disable()
+            machine.enable(new_conf.value)
+    elif new_conf:  # [confusing-consecutive-elif]
+        machine.enable(new_conf.value)
+
+
+def not_triggered_if_indented_block_ends_with_else(machine, old_conf, new_conf):
+    """Example code must not trigger the message, because the inner block ends with else.
+
+    Given an if-elif construct
+    When the body of the if ends with an else
+    Then no message shall be triggered.
+    """
+    if old_conf:
+        if not new_conf:
+            machine.disable()
+        elif old_conf.value != new_conf.value:
+            machine.disable()
+            machine.enable(new_conf.value)
+        else:
+            pass
+    elif new_conf:
+        machine.enable(new_conf.value)
+
+
+def not_triggered_if_indentend_block_ends_with_call(machine, old_conf, new_conf):
+    """
+    Example code must not trigger the message,
+
+    Given an if-elif construct
+    When the body of the if ends with a function call
+    Then no message shall be triggered.
+
+    Note: There is nothing special about the body ending with a function call.
+    This is just taken as a representative value for the equivalence class of
+    "every node class unrelated to if/elif/else".
+    """
+    if old_conf:
+        if not new_conf:
+            machine.disable()
+        elif old_conf.value != new_conf.value:
+            machine.disable()
+            machine.enable(new_conf.value)
+        print("Processed old configuration...")
+    elif new_conf:
+        machine.enable(new_conf.value)
+
+
+def triggered_if_elif_block_ends_with_elif(machine, old_conf, new_conf, new_new_conf):
+    """Example code that will trigger the message
+
+    Given an if-elif-elif construct
+    When the body of the first elif ends with an elif
+    Then the message confusing-consecutive-elif must be triggered.
+    """
+    if old_conf:
+        machine.disable()
+    elif not new_conf:
+        if new_new_conf:
+            machine.disable()
+        elif old_conf.value != new_conf.value:
+            machine.disable()
+            machine.enable(new_conf.value)
+    elif new_conf:  # [confusing-consecutive-elif]
+        machine.enable(new_conf.value)
+
+
+def triggered_if_block_ends_with_if(machine, old_conf, new_conf, new_new_conf):
+    """Example code that will trigger the message
+
+    Given an if-elif construct
+    When the body of the if ends with an if
+    Then the message confusing-consecutive-elif must be triggered.
+    """
+    if old_conf:
+        if new_new_conf:
+            machine.disable()
+    elif new_conf:  # [confusing-consecutive-elif]
+        machine.enable(new_conf.value)
+
+
+def not_triggered_if_indented_block_ends_with_ifexp(machine, old_conf, new_conf):
+    """
+    Example code must not trigger the message,
+
+    Given an if-elif construct
+    When the body of the if ends with an if expression
+    Then no message shall be triggered.
+    """
+    if old_conf:
+        if not new_conf:
+            machine.disable()
+        print("Processed old configuration...")
+    elif new_conf:
+        machine.enable(new_conf.value)
+
+
+def not_triggered_if_outer_block_does_not_have_elif(machine, old_conf, new_conf):
+    """Example code must not trigger the message
+
+    Given an if construct without an elif
+    When the body of the if ends with an if
+    Then no message shall be triggered.
+    """
+    if old_conf:
+        if not new_conf:
+            machine.disable()
+        elif old_conf.value != new_conf.value:
+            machine.disable()
+            machine.enable(new_conf.value)
+    else:
+        pass
+
+
+def not_triggered_if_outer_block_continues_with_if(machine, old_conf, new_conf, new_new_conf):
+    """Example code that will trigger the message
+
+    Given an if construct which continues with a new if construct
+    When the body of the first if ends with an if expression
+    Then no message shall be triggered.
+    """
+    if old_conf:
+        if new_new_conf:
+            machine.disable()
+        elif old_conf.value != new_conf.value:
+            machine.disable()
+            machine.enable(new_conf.value)
+    if new_conf:
+        machine.enable(new_conf.value)

testbed/pylint-dev__pylint/tests/functional/ext/confusing_elif/confusing_elif.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.confusing_elif

testbed/pylint-dev__pylint/tests/functional/ext/confusing_elif/confusing_elif.txt

@@ -0,0 +1,3 @@
+confusing-consecutive-elif:17:4:18:38:triggered_if_if_block_ends_with_elif:Consecutive elif with differing indentation level, consider creating a function to separate the inner elif:UNDEFINED
+confusing-consecutive-elif:78:4:79:38:triggered_if_elif_block_ends_with_elif:Consecutive elif with differing indentation level, consider creating a function to separate the inner elif:UNDEFINED
+confusing-consecutive-elif:92:4:93:38:triggered_if_block_ends_with_if:Consecutive elif with differing indentation level, consider creating a function to separate the inner elif:UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/consider_ternary_expression/consider_ternary_expression.py

@@ -0,0 +1,36 @@
+# pylint: disable=invalid-name, undefined-variable, unused-variable, missing-function-docstring, missing-module-docstring
+# pylint: disable=unsupported-assignment-operation, line-too-long
+
+if f():  # [consider-ternary-expression]
+    x = 4
+else:
+    x = 5
+
+if g():
+    y = 3
+elif h():
+    y = 4
+else:
+    y = 5
+
+def a():
+    if i():  # [consider-ternary-expression]
+        z = 4
+    else:
+        z = 5
+
+if f():
+    x = 4
+    print(x)
+else:
+    x = 5
+
+if f():
+    x[0] = 4
+else:
+    x = 5
+
+if f():
+    x = 4
+else:
+    y = 5

testbed/pylint-dev__pylint/tests/functional/ext/consider_ternary_expression/consider_ternary_expression.rc

@@ -0,0 +1,2 @@
+[MAIN]
+load-plugins=pylint.extensions.consider_ternary_expression,

testbed/pylint-dev__pylint/tests/functional/ext/consider_ternary_expression/consider_ternary_expression.txt

@@ -0,0 +1,2 @@
+consider-ternary-expression:4:0:7:9::Consider rewriting as a ternary expression:UNDEFINED
+consider-ternary-expression:17:4:20:13:a:Consider rewriting as a ternary expression:UNDEFINED

testbed/pylint-dev__pylint/tests/functional/ext/docparams/docparams.py

@@ -0,0 +1,108 @@
+"""Fixture for testing missing documentation in docparams."""
+# pylint: disable=broad-exception-raised
+
+def _private_func1(  # [missing-return-doc, missing-return-type-doc, missing-any-param-doc]
+    param1,
+):
+    """This is a test docstring without returns"""
+    return param1
+
+
+def _private_func2(  # [missing-yield-doc, missing-yield-type-doc, missing-any-param-doc]
+    param1,
+):
+    """This is a test docstring without yields"""
+    yield param1
+
+
+def _private_func3(param1):  # [missing-raises-doc, missing-any-param-doc]
+    """This is a test docstring without raises"""
+    raise Exception("Example")
+
+
+def public_func1(param1):  # [missing-any-param-doc]
+    """This is a test docstring without params"""
+    print(param1)
+
+
+# pylint: disable-next=line-too-long
+async def _async_private_func1(  # [missing-return-doc, missing-return-type-doc, missing-any-param-doc]
+    param1,
+):
+    """This is a test docstring without returns"""
+    return param1
+
+
+# pylint: disable-next=line-too-long
+async def _async_private_func2(  # [missing-yield-doc, missing-yield-type-doc, missing-any-param-doc]
+    param1,
+):
+    """This is a test docstring without yields"""
+    yield param1
+
+
+async def _async_private_func3(param1):  # [missing-raises-doc, missing-any-param-doc]
+    """This is a test docstring without raises"""
+    raise Exception("Example")
+
+
+async def async_public_func1(param1):  # [missing-any-param-doc]
+    """This is a test docstring without params"""
+    print(param1)
+
+
+def differing_param_doc(par1: int) -> int:  # [differing-param-doc]
+    """This is a test docstring documenting one non-existing param
+
+    :param par1: some param
+    :param param: some param
+    :return: the sum of the params
+    """
+
+    return par1
+
+
+def differing_param_doc_kwords_only(*, par1: int) -> int:  # [differing-param-doc]
+    """This is a test docstring documenting one non-existing param
+
+    :param par1: some param
+    :param param: some param
+    :return: the sum of the params
+    """
+
+    return par1
+
+
+def missing_type_doc(par1) -> int:  # [missing-type-doc]
+    """This is a test docstring params where the type is not specified
+
+    :param par1: some param
+    :return: the param
+    """
+
+    return par1
+
+
+def missing_type_doc_kwords_only(*, par1) -> int:  # [missing-type-doc]
+    """This is a test docstring params where the type is not specified
+
+    :param par1: some param
+    :return: the param
+    """
+
+    return par1
+
+
+def params_are_documented(par1: int, *, par2: int) -> int:
+    """This is a test docstring params where nothing is raised as it is all documented
+
+    :param par1: some param
+    :param par2: some other param
+    :return: the sum of params
+    """
+
+    return par1 + par2
+
+
+# Only check raise nodes within FunctionDefs
+raise Exception()

testbed/pylint-dev__pylint/tests/functional/ext/docparams/docparams.rc

@@ -0,0 +1,9 @@
+[MAIN]
+load-plugins = pylint.extensions.docparams
+no-docstring-rgx = ONLYVERYSPECIFICFUNCTIONS
+
+[BASIC]
+accept-no-param-doc = no
+accept-no-raise-doc = no
+accept-no-return-doc = no
+accept-no-yields-doc = no

testbed/pylint-dev__pylint/tests/functional/ext/docparams/docparams.txt

@@ -0,0 +1,22 @@
+missing-any-param-doc:4:0:4:18:_private_func1:"Missing any documentation in ""_private_func1""":HIGH
+missing-return-doc:4:0:4:18:_private_func1:Missing return documentation:HIGH
+missing-return-type-doc:4:0:4:18:_private_func1:Missing return type documentation:HIGH
+missing-any-param-doc:11:0:11:18:_private_func2:"Missing any documentation in ""_private_func2""":HIGH
+missing-yield-doc:11:0:11:18:_private_func2:Missing yield documentation:HIGH
+missing-yield-type-doc:11:0:11:18:_private_func2:Missing yield type documentation:HIGH
+missing-any-param-doc:18:0:18:18:_private_func3:"Missing any documentation in ""_private_func3""":HIGH
+missing-raises-doc:18:0:18:18:_private_func3:"""Exception"" not documented as being raised":HIGH
+missing-any-param-doc:23:0:23:16:public_func1:"Missing any documentation in ""public_func1""":HIGH
+missing-any-param-doc:29:0:29:30:_async_private_func1:"Missing any documentation in ""_async_private_func1""":HIGH
+missing-return-doc:29:0:29:30:_async_private_func1:Missing return documentation:HIGH
+missing-return-type-doc:29:0:29:30:_async_private_func1:Missing return type documentation:HIGH
+missing-any-param-doc:37:0:37:30:_async_private_func2:"Missing any documentation in ""_async_private_func2""":HIGH
+missing-yield-doc:37:0:37:30:_async_private_func2:Missing yield documentation:HIGH
+missing-yield-type-doc:37:0:37:30:_async_private_func2:Missing yield type documentation:HIGH
+missing-any-param-doc:44:0:44:30:_async_private_func3:"Missing any documentation in ""_async_private_func3""":HIGH
+missing-raises-doc:44:0:44:30:_async_private_func3:"""Exception"" not documented as being raised":HIGH
+missing-any-param-doc:49:0:49:28:async_public_func1:"Missing any documentation in ""async_public_func1""":HIGH
+differing-param-doc:54:0:54:23:differing_param_doc:"""param"" differing in parameter documentation":HIGH
+differing-param-doc:65:0:65:35:differing_param_doc_kwords_only:"""param"" differing in parameter documentation":HIGH
+missing-type-doc:76:0:76:20:missing_type_doc:"""par1"" missing in parameter type documentation":HIGH
+missing-type-doc:86:0:86:32:missing_type_doc_kwords_only:"""par1"" missing in parameter type documentation":HIGH

testbed/pylint-dev__pylint/tests/functional/ext/docparams/docparams_py38.py

@@ -0,0 +1,34 @@
+"""Fixture for testing missing documentation in docparams (Python >=3.8 only)."""
+
+
+def differing_param_doc_pos_only(par1: int, /) -> int:  # [differing-param-doc]
+    """This is a test docstring documenting one non-existing param
+
+    :param par1: some param
+    :param param: some param
+    :return: the sum of the params
+    """
+
+    return par1
+
+
+def missing_type_doc_pos_only(par1, /) -> int:  # [missing-type-doc]
+    """This is a test docstring params where the type is not specified
+
+    :param par1: some param
+    :return: the param
+    """
+
+    return par1
+
+
+def params_are_documented(par1: int, /, par2: int, *, par3: int) -> int:
+    """This is a test docstring params where nothing is raised as it is all documented
+
+    :param par1: some param
+    :param par2: some other param
+    :param par3: some other param
+    :return: the sum of params
+    """
+
+    return par1 + par2 + par3

testbed/pylint-dev__pylint/tests/functional/ext/docparams/docparams_py38.rc

@@ -0,0 +1,11 @@
+[MAIN]
+load-plugins = pylint.extensions.docparams
+
+[BASIC]
+accept-no-param-doc = no
+accept-no-raise-doc = no
+accept-no-return-doc = no
+accept-no-yields-doc = no
+
+[testoptions]
+min_pyver=3.8

testbed/pylint-dev__pylint/tests/functional/ext/docparams/docparams_py38.txt

@@ -0,0 +1,2 @@
+differing-param-doc:4:0:4:32:differing_param_doc_pos_only:"""param"" differing in parameter documentation":HIGH
+missing-type-doc:15:0:15:29:missing_type_doc_pos_only:"""par1"" missing in parameter type documentation":HIGH

testbed/pylint-dev__pylint/tests/functional/ext/docparams/missing_param_doc.py

@@ -0,0 +1,142 @@
+#pylint: disable=missing-module-docstring
+
+def foobar1(arg1, arg2): #[missing-any-param-doc]
+    """function foobar ...
+    """
+    print(arg1, arg2)
+
+def foobar2(arg1, arg2): #[missing-any-param-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    """
+    print(arg1, arg2)
+
+def foobar3(arg1, arg2, arg3): #[missing-param-doc, missing-type-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    arg1: int
+    arg3: float
+    """
+    print(arg1, arg2, arg3)
+
+def foobar4(arg1, arg2): #[missing-param-doc, missing-type-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    arg1: int
+        description
+    """
+    print(arg1, arg2)
+
+def foobar5(arg1, arg2): #[missing-type-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    arg1:
+        description
+    arg2: str
+    """
+    print(arg1, arg2)
+
+def foobar6(arg1, arg2, arg3): #[missing-param-doc, missing-type-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    arg1: int
+        description
+    arg2: int
+    """
+    print(arg1, arg2, arg3)
+
+def foobar7(arg1, arg2): #[missing-any-param-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    arg1
+    """
+    print(arg1, arg2)
+
+def foobar8(arg1): #[missing-any-param-doc]
+    """function foobar"""
+
+    print(arg1)
+
+def foobar9(arg1, arg2, arg3):
+    """function foobar ...
+    Parameters
+    ----------
+    arg1: int
+    arg2: int
+    arg3: str
+    """
+    print(arg1, arg2, arg3)
+
+def foobar10(arg1, arg2, arg3): #[missing-type-doc]
+    """function foobar ...
+    Parameters
+    ----------
+    arg1:
+        desc1
+    arg2: int
+    arg3:
+        desc3
+    """
+    print(arg1, arg2, arg3)
+
+def foobar11(arg1, arg2): #[missing-any-param-doc]
+    """function foobar ...
+    Args
+    ----------
+    arg1
+    arg2
+    """
+    print(arg1, arg2)
+
+def foobar12(arg1, arg2, arg3): #[missing-param-doc, missing-type-doc]
+    """function foobar ...
+    Args
+    ----------
+    arg1: int
+    arg2:
+        does something
+    arg3
+    """
+    print(arg1, arg2, arg3)
+
+def foobar13(arg1, *args, arg3=";"):
+    """Description of the function
+
+    Parameters
+    ----------
+    arg1 : str
+        Path to the input.
+    *args :
+        Relevant parameters.
+    arg3 : str, optional
+        File separator.
+    """
+    print(arg1, args, arg3)
+
+def foobar14(arg1, *args):
+    """Description of the function
+
+    Parameters
+    ----------
+    arg1 : str
+        Path to the input.
+    *args :
+        Relevant parameters.
+    """
+    print(arg1, args)
+
+def foobar15(*args):
+    """Description of the function
+
+    Parameters
+    ----------
+    *args :
+        Relevant parameters.
+    """
+    print(args)

testbed/pylint-dev__pylint/tests/functional/ext/docparams/missing_param_doc.rc

@@ -0,0 +1,8 @@
+[MAIN]
+load-plugins=pylint.extensions.docparams,
+
+[PARAMETER_DOCUMENTATION]
+accept-no-param-doc=no
+accept-no-raise-doc=no
+accept-no-return-doc=no
+accept-no-yields-doc=no

testbed/pylint-dev__pylint/tests/functional/ext/docparams/missing_param_doc.txt

@@ -0,0 +1,15 @@
+missing-any-param-doc:3:0:3:11:foobar1:"Missing any documentation in ""foobar1""":HIGH
+missing-any-param-doc:8:0:8:11:foobar2:"Missing any documentation in ""foobar2""":HIGH
+missing-param-doc:15:0:15:11:foobar3:"""arg2"" missing in parameter documentation":HIGH
+missing-type-doc:15:0:15:11:foobar3:"""arg2"" missing in parameter type documentation":HIGH
+missing-param-doc:24:0:24:11:foobar4:"""arg2"" missing in parameter documentation":HIGH
+missing-type-doc:24:0:24:11:foobar4:"""arg2"" missing in parameter type documentation":HIGH
+missing-type-doc:33:0:33:11:foobar5:"""arg1"" missing in parameter type documentation":HIGH
+missing-param-doc:43:0:43:11:foobar6:"""arg3"" missing in parameter documentation":HIGH
+missing-type-doc:43:0:43:11:foobar6:"""arg3"" missing in parameter type documentation":HIGH
+missing-any-param-doc:53:0:53:11:foobar7:"Missing any documentation in ""foobar7""":HIGH
+missing-any-param-doc:61:0:61:11:foobar8:"Missing any documentation in ""foobar8""":HIGH
+missing-type-doc:76:0:76:12:foobar10:"""arg1, arg3"" missing in parameter type documentation":HIGH
+missing-any-param-doc:88:0:88:12:foobar11:"Missing any documentation in ""foobar11""":HIGH
+missing-param-doc:97:0:97:12:foobar12:"""arg3"" missing in parameter documentation":HIGH
+missing-type-doc:97:0:97:12:foobar12:"""arg2, arg3"" missing in parameter type documentation":HIGH

testbed/pylint-dev__pylint/tests/functional/ext/docparams/parameter/missing_param_doc.py

@@ -0,0 +1,12 @@
+"""Tests for missing-param-doc and missing-type-doc for non-specified style docstrings
+with accept-no-param-doc = yes
+"""
+# pylint: disable=invalid-name, unused-argument
+
+
+def test_tolerate_no_param_documentation_at_all(x, y):
+    """Example of a function with no parameter documentation at all
+
+    No error message is emitted.
+
+    missing parameter documentation"""

testbed/pylint-dev__pylint/tests/functional/ext/docparams/parameter/missing_param_doc.rc

@@ -0,0 +1,7 @@
+[MAIN]
+load-plugins = pylint.extensions.docparams
+
+[BASIC]
+accept-no-param-doc=yes
+docstring-min-length: -1
+no-docstring-rgx=^$

testbed/pylint-dev__pylint/tests/functional/ext/docparams/parameter/missing_param_doc_required.py

@@ -0,0 +1,51 @@
+"""Tests for missing-param-doc and missing-type-doc for non-specified style docstrings
+with accept-no-param-doc = no
+"""
+# pylint: disable=invalid-name, unused-argument, too-few-public-methods
+
+
+def test_don_t_tolerate_no_param_documentation_at_all(x, y):  # [missing-any-param-doc]
+    """Example of a function with no parameter documentation at all
+
+    Missing documentation error message is emitted.
+
+    missing parameter documentation"""
+
+
+def test_see_tolerate_no_param_documentation_at_all(x, y):
+    """Example for the usage of "For the parameters, see"
+    to suppress missing-param warnings.
+
+    For the parameters, see :func:`blah`
+    """
+
+
+class ClassFoo:
+    """Example usage of "For the parameters, see" in init docstring"""
+
+    def __init__(self, x, y):
+        """docstring foo constructor
+
+        For the parameters, see :func:`bla`
+        """
+
+
+class ClassFooTwo:
+    """test_see_sentence_for_constr_params_in_class
+    Example usage of "For the parameters, see" in class docstring
+
+    For the parameters, see :func:`bla`
+    """
+
+    def __init__(self, x, y):
+        """init"""
+
+
+def test_kwonlyargs_are_taken_in_account(  # [missing-param-doc, missing-type-doc]
+    arg, *, kwonly, missing_kwonly
+):
+    """The docstring
+
+    :param int arg: The argument.
+    :param bool kwonly: A keyword-arg.
+    """

testbed/pylint-dev__pylint/tests/functional/ext/docparams/parameter/missing_param_doc_required.rc

@@ -0,0 +1,7 @@
+[MAIN]
+load-plugins = pylint.extensions.docparams
+
+[BASIC]
+accept-no-param-doc=no
+docstring-min-length: -1
+no-docstring-rgx=^$