Path 1: 114 calls (0.75)

→ original list (114)

→ overridden list (114)

→ dummy_parameter_regex Pattern (114)

↩ return [] (114)

9 run 10 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 2: 11 calls (0.07)

→ original list (11)

→ overridden list (11)

→ dummy_parameter_regex Pattern (11)

↩ return ["Parameter 'fruit_name' has been renamed to 'orange_name' in"] (3) ["Parameter 'index' has been renamed to 'key' in"] (3) ["Parameter 'args' has been...

12 run 7 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 3: 7 calls (0.05)

→ original list (7)

→ overridden list (7)

→ dummy_parameter_regex Pattern (7)

↩ return ['Number of parameters '] (7)

⚠ exception NoDefault (7)

12 run 7 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 4: 7 calls (0.05)

→ original [] (7)

→ overridden [] (7)

→ dummy_parameter_regex Pattern (7)

↩ return [] (7)

4 run 15 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 5: 5 calls (0.03)

→ original list (5)

→ overridden list (5)

→ dummy_parameter_regex Pattern (5)

↩ return [] (5)

⚠ exception GeneratorExit (5)

10 run 9 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 6: 2 calls (0.01)

→ original list (2)

→ overridden list (2)

→ dummy_parameter_regex Pattern (2)

↩ return ['Number of parameters '] (2)

9 run 10 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 7: 2 calls (0.01)

→ original list (2)

→ overridden list (2)

→ dummy_parameter_regex Pattern (2)

↩ return [] (2)

12 run 7 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 8: 1 calls (0.01)

→ original list (1)

→ overridden [] (1)

→ dummy_parameter_regex Pattern (1)

↩ return ['Number of parameters '] (1)

5 run 14 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 9: 1 calls (0.01)

→ original list (1)

→ overridden list (1)

→ dummy_parameter_regex Pattern (1)

↩ return ['Number of parameters '] (1)

⚠ exception NoDefault (1)

15 run 4 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result
            

Path 10: 1 calls (0.01)

→ original [] (1)

→ overridden list (1)

→ dummy_parameter_regex Pattern (1)

↩ return ['Number of parameters '] (1)

⚠ exception NoDefault (1)

9 run 10 not run

1def _has_different_parameters(
2    original: list[nodes.AssignName],
3    overridden: list[nodes.AssignName],
4    dummy_parameter_regex: Pattern[str],
5) -> list[str]:
6    result: list[str] = []
7    zipped = zip_longest(original, overridden)
8    for original_param, overridden_param in zipped:
9        if not overridden_param:
10            return ["Number of parameters "]
11
12        if not original_param:
13            try:
14                overridden_param.parent.default_value(overridden_param.name)
15                continue
16            except astroid.NoDefault:
17                return ["Number of parameters "]
18
19        # check for the arguments' name
20        names = [param.name for param in (original_param, overridden_param)]
21        if any(dummy_parameter_regex.match(name) for name in names):
22            continue
23        if original_param.name != overridden_param.name:
24            result.append(
25                f"Parameter '{original_param.name}' has been renamed "
26                f"to '{overridden_param.name}' in"
27            )
28
29    return result