| # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0 |
| # For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt |
| |
| """Tests for coverage.py's code parsing.""" |
| |
| from __future__ import annotations |
| |
| import ast |
| import re |
| import textwrap |
| import tokenize |
| from unittest import mock |
| |
| import pytest |
| |
| from coverage import env |
| from coverage.exceptions import NoSource, NotPython |
| from coverage.parser import PythonParser, is_constant_test_expr, multiline_map_from_text |
| from coverage.types import TLineNo |
| |
| from tests.coveragetest import CoverageTest |
| from tests.helpers import arcz_to_arcs |
| |
| |
| class PythonParserTestBase(CoverageTest): |
| """Tests for coverage.py's Python code parsing.""" |
| |
| run_in_temp_dir = False |
| |
| def parse_text(self, text: str, exclude: str = "nocover") -> PythonParser: |
| """Parse `text` as source, and return the `PythonParser` used.""" |
| text = textwrap.dedent(text) |
| parser = PythonParser(text=text, exclude=exclude) |
| parser.parse_source() |
| return parser |
| |
| |
| class PythonParserTest(PythonParserTestBase): |
| """Tests of coverage.parser.""" |
| |
| def test_exit_counts(self) -> None: |
| parser = self.parse_text("""\ |
| # check some basic branch counting |
| class Foo: |
| def foo(self, a): |
| if a: |
| return 5 |
| else: |
| return 7 |
| |
| class Bar: |
| pass |
| """) |
| assert parser.exit_counts() == { |
| 2: 1, |
| 3: 1, |
| 4: 2, |
| 5: 1, |
| 7: 1, |
| 9: 1, |
| 10: 1, |
| } |
| |
| def test_try_except(self) -> None: |
| parser = self.parse_text("""\ |
| try: |
| a = 2 |
| except ValueError: |
| a = 4 |
| except ZeroDivideError: |
| a = 6 |
| except: |
| a = 8 |
| b = 9 |
| """) |
| assert parser.exit_counts() == { |
| 1: 1, |
| 2: 1, |
| 3: 1, |
| 4: 1, |
| 5: 1, |
| 6: 1, |
| 7: 1, |
| 8: 1, |
| 9: 1, |
| } |
| |
| def test_excluded_classes(self) -> None: |
| parser = self.parse_text("""\ |
| class Foo: |
| def __init__(self): |
| pass |
| |
| if len([]): # nocover |
| class Bar: |
| pass |
| """) |
| assert parser.exit_counts() == {2: 1, 3: 1} |
| |
| def test_missing_branch_to_excluded_code(self) -> None: |
| parser = self.parse_text("""\ |
| if fooey: |
| a = 2 |
| else: # nocover |
| a = 4 |
| b = 5 |
| """) |
| assert parser.exit_counts() == {1: 1, 2: 1, 5: 1} |
| parser = self.parse_text("""\ |
| def foo(): |
| if fooey: |
| a = 3 |
| else: |
| a = 5 |
| b = 6 |
| """) |
| assert parser.exit_counts() == {1: 1, 2: 2, 3: 1, 5: 1, 6: 1} |
| parser = self.parse_text("""\ |
| def foo(): |
| if fooey: |
| a = 3 |
| else: # nocover |
| a = 5 |
| b = 6 |
| """) |
| assert parser.exit_counts() == {1: 1, 2: 1, 3: 1, 6: 1} |
| |
| @pytest.mark.parametrize( |
| "text", |
| [ |
| pytest.param("0 spaces\n 2\n 1", id="bad_indent"), |
| pytest.param("'''", id="string_eof"), |
| pytest.param("$hello", id="dollar"), |
| # on 3.10 this passes ast.parse but fails on tokenize.generate_tokens |
| pytest.param( |
| "\r'\\\n'''", |
| id="leading_newline_eof", |
| marks=[ |
| pytest.mark.skipif(env.PYVERSION >= (3, 12), reason="parses fine in 3.12"), |
| ], |
| ), |
| ], |
| ) |
| def test_not_python(self, text: str) -> None: |
| msg = r"Couldn't parse '<code>' as Python source: ['\"].*['\"] at line \d+" |
| with pytest.raises(NotPython, match=msg): |
| _ = self.parse_text(text) |
| |
| def test_empty_decorated_function(self) -> None: |
| parser = self.parse_text("""\ |
| def decorator(func): |
| return func |
| |
| @decorator |
| def foo(self): |
| '''Docstring''' |
| |
| @decorator |
| def bar(self): |
| pass |
| """) |
| |
| assert parser.statements == {1, 2, 4, 5, 8, 9, 10} |
| assert parser.arcs() == set(arcz_to_arcs("14 45 58 89 9. 2. A-8")) |
| assert parser.exit_counts() == {1: 1, 2: 1, 4: 1, 5: 1, 8: 1, 9: 1, 10: 1} |
| |
| def test_nested_context_managers(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/1876 |
| parser = self.parse_text("""\ |
| a = 1 |
| with suppress(ValueError): |
| with suppress(ValueError): |
| x = 4 |
| with suppress(ValueError): |
| x = 6 |
| with suppress(ValueError): |
| x = 8 |
| a = 9 |
| """) |
| |
| one_nine = set(range(1, 10)) |
| assert parser.statements == one_nine |
| assert parser.exit_counts() == dict.fromkeys(one_nine, 1) |
| |
| def test_module_docstrings(self) -> None: |
| parser = self.parse_text("""\ |
| '''The docstring on line 1''' |
| a = 2 |
| """) |
| assert {2} == parser.statements |
| |
| parser = self.parse_text("""\ |
| # Docstring is not line 1 |
| '''The docstring on line 2''' |
| a = 3 |
| """) |
| assert {3} == parser.statements |
| |
| def test_fuzzed_double_parse(self) -> None: |
| # https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=50381 |
| # The second parse used to raise `TypeError: 'NoneType' object is not iterable` |
| msg = ( |
| r"(EOF in multi-line statement)" # before 3.12.0b1 |
| + r"|(unmatched ']')" # after 3.12.0b1 |
| ) |
| with pytest.raises(NotPython, match=msg): |
| self.parse_text("]") |
| with pytest.raises(NotPython, match=msg): |
| self.parse_text("]") |
| |
| def test_bug_1891(self) -> None: |
| # These examples exercise code paths I thought were impossible. |
| parser = self.parse_text("""\ |
| res = siblings( |
| 'configure', |
| **ca, |
| ) |
| """) |
| assert parser.exit_counts() == {1: 1} |
| # In conftest.py, we silence the SyntaxWarning this code causes. If |
| # we remove this code, we can probably remove that warning. |
| parser = self.parse_text("""\ |
| def g2(): |
| try: |
| return 2 |
| finally: |
| return 3 |
| """) |
| assert parser.exit_counts() == {1: 1, 2: 1, 3: 1, 5: 1} |
| |
| def test_fuzzed_weirdness(self) -> None: |
| # This used to cause a `min of empty sequence` error: |
| self.parse_text("\r\\\n\n\t\t\\\n\n") |
| |
| |
| class ExclusionParserTest(PythonParserTestBase): |
| """Tests for the exclusion code in PythonParser.""" |
| |
| def test_simple(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 1; b = 2 |
| |
| if len([]): |
| a = 4 # nocover |
| """, |
| ) |
| assert parser.statements == {1, 3} |
| |
| def test_excluding_if_suite(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 1; b = 2 |
| |
| if len([]): # nocover |
| a = 4 |
| b = 5 |
| c = 6 |
| assert a == 1 and b == 2 |
| """, |
| ) |
| assert parser.statements == {1, 7} |
| |
| def test_excluding_if_but_not_else_suite(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 1; b = 2 |
| |
| if len([]): # nocover |
| a = 4 |
| b = 5 |
| c = 6 |
| else: |
| a = 8 |
| b = 9 |
| assert a == 8 and b == 9 |
| """, |
| ) |
| assert parser.statements == {1, 8, 9, 10} |
| |
| def test_excluding_else_suite(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 1; b = 2 |
| |
| if 1==1: |
| a = 4 |
| b = 5 |
| c = 6 |
| else: # nocover |
| a = 8 |
| b = 9 |
| assert a == 4 and b == 5 and c == 6 |
| """, |
| ) |
| assert parser.statements == {1, 3, 4, 5, 6, 10} |
| parser = self.parse_text( |
| """\ |
| a = 1; b = 2 |
| |
| if 1==1: |
| a = 4 |
| b = 5 |
| c = 6 |
| |
| # Lots of comments to confuse the else handler. |
| # more. |
| |
| else: # nocover |
| |
| # Comments here too. |
| |
| a = 8 |
| b = 9 |
| assert a == 4 and b == 5 and c == 6 |
| """, |
| ) |
| assert parser.statements == {1, 3, 4, 5, 6, 17} |
| |
| def test_excluding_oneline_if(self) -> None: |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| a = 2 |
| if len([]): x = 3 # nocover |
| b = 4 |
| |
| foo() |
| """, |
| ) |
| assert parser.statements == {1, 2, 4, 6} |
| |
| def test_excluding_a_colon_not_a_suite(self) -> None: |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| l = list(range(10)) |
| a = l[:3] # nocover |
| b = 4 |
| |
| foo() |
| """, |
| ) |
| assert parser.statements == {1, 2, 4, 6} |
| |
| def test_excluding_for_suite(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| for i in [1,2,3,4,5]: # nocover |
| a += i |
| assert a == 15 |
| """, |
| ) |
| assert parser.statements == {1, 4} |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| for i in [1, |
| 2,3,4, |
| 5]: # nocover |
| a += i |
| assert a == 15 |
| """, |
| ) |
| assert parser.statements == {1, 6} |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| for i in [1,2,3,4,5 |
| ]: # nocover |
| a += i |
| break |
| a = 99 |
| assert a == 1 |
| """, |
| ) |
| assert parser.statements == {1, 7} |
| |
| def test_excluding_for_else(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| for i in range(5): |
| a += i+1 |
| break |
| else: # nocover |
| a = 123 |
| assert a == 1 |
| """, |
| ) |
| assert parser.statements == {1, 2, 3, 4, 7} |
| |
| def test_excluding_while(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 3; b = 0 |
| while a*b: # nocover |
| b += 1 |
| break |
| assert a == 3 and b == 0 |
| """, |
| ) |
| assert parser.statements == {1, 5} |
| parser = self.parse_text( |
| """\ |
| a = 3; b = 0 |
| while ( |
| a*b |
| ): # nocover |
| b += 1 |
| break |
| assert a == 3 and b == 0 |
| """, |
| ) |
| assert parser.statements == {1, 7} |
| |
| def test_excluding_while_else(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 3; b = 0 |
| while a: |
| b += 1 |
| break |
| else: # nocover |
| b = 123 |
| assert a == 3 and b == 1 |
| """, |
| ) |
| assert parser.statements == {1, 2, 3, 4, 7} |
| |
| def test_excluding_try_except(self) -> None: |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| try: |
| a = 1 |
| except: # nocover |
| a = 99 |
| assert a == 1 |
| """, |
| ) |
| assert parser.statements == {1, 2, 3, 6} |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| try: |
| a = 1 |
| raise Exception("foo") |
| except: |
| a = 99 |
| assert a == 99 |
| """, |
| ) |
| assert parser.statements == {1, 2, 3, 4, 5, 6, 7} |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| try: |
| a = 1 |
| raise Exception("foo") |
| except ImportError: # nocover |
| a = 99 |
| except: |
| a = 123 |
| assert a == 123 |
| """, |
| ) |
| assert parser.statements == {1, 2, 3, 4, 7, 8, 9} |
| |
| def test_excluding_if_pass(self) -> None: |
| # From a comment on the coverage.py page by Michael McNeil Forbes: |
| parser = self.parse_text( |
| """\ |
| def f(): |
| if False: # pragma: nocover |
| pass # This line still reported as missing |
| if False: # pragma: nocover |
| x = 1 # Now it is skipped. |
| |
| f() |
| """, |
| ) |
| assert parser.statements == {1, 7} |
| |
| def test_multiline_if_no_branch(self) -> None: |
| # From https://github.com/coveragepy/coveragepy/issues/754 |
| parser = self.parse_text( |
| """\ |
| if (this_is_a_verylong_boolean_expression == True # pragma: no branch |
| and another_long_expression and here_another_expression): |
| do_something() |
| """, |
| ) |
| parser2 = self.parse_text( |
| """\ |
| if this_is_a_verylong_boolean_expression == True and another_long_expression \\ |
| and here_another_expression: # pragma: no branch |
| do_something() |
| """, |
| ) |
| assert parser.statements == parser2.statements == {1, 3} |
| pragma_re = ".*pragma: no branch.*" |
| assert parser.lines_matching(pragma_re) == parser2.lines_matching(pragma_re) |
| |
| def test_excluding_function(self) -> None: |
| parser = self.parse_text( |
| """\ |
| def fn(foo): # nocover |
| a = 1 |
| b = 2 |
| c = 3 |
| |
| x = 1 |
| assert x == 1 |
| """, |
| ) |
| assert parser.statements == {6, 7} |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| def very_long_function_to_exclude_name(very_long_argument1, |
| very_long_argument2): |
| pass |
| assert a == 0 |
| """, |
| exclude="function_to_exclude", |
| ) |
| assert parser.statements == {1, 5} |
| parser = self.parse_text( |
| """\ |
| a = 0 |
| def very_long_function_to_exclude_name( |
| very_long_argument1, |
| very_long_argument2 |
| ): |
| pass |
| assert a == 0 |
| """, |
| exclude="function_to_exclude", |
| ) |
| assert parser.statements == {1, 7} |
| # linters and formatters can't agree about whether strings are too |
| # long, so format in the long variable names that make them too long. |
| long_arg = "super_long_input_argument" |
| parser = self.parse_text( |
| f"""\ |
| def my_func( |
| {long_arg}_0=0, |
| {long_arg}_1=1, |
| {long_arg}_2=2): |
| pass |
| |
| def my_func_2({long_arg}_0=0, {long_arg}_1=1, {long_arg}_2=2): |
| pass |
| """, |
| exclude="my_func", |
| ) |
| assert parser.statements == set() |
| parser = self.parse_text( |
| f"""\ |
| def my_func( |
| {long_arg}_0=0, |
| {long_arg}_1=1, |
| {long_arg}_2=2): |
| pass |
| |
| def my_func_2({long_arg}_0=0, {long_arg}_1=1, {long_arg}_2=2): |
| pass |
| """, |
| exclude="my_func_2", |
| ) |
| assert parser.statements == {1, 5} |
| parser = self.parse_text( |
| f"""\ |
| def my_func ( |
| {long_arg}_0=0, |
| {long_arg}_1=1, |
| {long_arg}_2=2): |
| pass |
| |
| def my_func_2 ({long_arg}_0=0, {long_arg}_1=1, {long_arg}_2=2): |
| pass |
| """, |
| exclude="my_func_2", |
| ) |
| assert parser.statements == {1, 5} |
| parser = self.parse_text( |
| f"""\ |
| def my_func ( |
| {long_arg}_0=0, |
| {long_arg}_1=1, |
| {long_arg}_2=2): |
| pass |
| |
| def my_func_2 ({long_arg}_0=0, {long_arg}_1=1, {long_arg}_2=2): |
| pass |
| """, |
| exclude="my_func", |
| ) |
| assert parser.statements == set() |
| parser = self.parse_text( |
| f"""\ |
| def my_func \ |
| ( |
| {long_arg}_0=0, |
| {long_arg}_1=1 |
| ): |
| pass |
| |
| def my_func_2({long_arg}_0=0, {long_arg}_1=1, {long_arg}_2=2): |
| pass |
| """, |
| exclude="my_func_2", |
| ) |
| assert parser.statements == {1, 5} |
| parser = self.parse_text( |
| f"""\ |
| def my_func \ |
| ( |
| {long_arg}_0=0, |
| {long_arg}_1=1 |
| ): |
| pass |
| |
| def my_func_2({long_arg}_0=0, {long_arg}_1=1, {long_arg}_2=2): |
| pass |
| """, |
| exclude="my_func", |
| ) |
| assert parser.statements == set() |
| |
| def test_excluding_bug1713(self) -> None: |
| parser = self.parse_text( |
| """\ |
| print("1") |
| |
| def hello_3(a): # pragma: nocover |
| match a: |
| case ("5" |
| | "6"): |
| print("7") |
| case "8": |
| print("9") |
| |
| print("11") |
| """, |
| ) |
| assert parser.statements == {1, 11} |
| parser = self.parse_text( |
| """\ |
| print("1") |
| |
| def hello_3(a): # nocover |
| if ("4" or |
| "5"): |
| print("6") |
| else: |
| print("8") |
| |
| print("10") |
| """, |
| ) |
| assert parser.statements == {1, 10} |
| parser = self.parse_text( |
| """\ |
| print(1) |
| |
| def func(a, b): |
| if a == 4: # nocover |
| func5() |
| if b: |
| print(7) |
| func8() |
| |
| print(10) |
| """, |
| ) |
| assert parser.statements == {1, 3, 10} |
| parser = self.parse_text( |
| """\ |
| class Foo: # pragma: nocover |
| def greet(self): |
| print("hello world") |
| """, |
| ) |
| assert parser.statements == set() |
| |
| def test_excluding_method(self) -> None: |
| parser = self.parse_text( |
| """\ |
| class Fooey: |
| def __init__(self): |
| self.a = 1 |
| |
| def foo(self): # nocover |
| return self.a |
| |
| x = Fooey() |
| assert x.a == 1 |
| """, |
| ) |
| assert parser.statements == {1, 2, 3, 8, 9} |
| parser = self.parse_text( |
| """\ |
| class Fooey: |
| def __init__(self): |
| self.a = 1 |
| |
| def very_long_method_to_exclude_name( |
| very_long_argument1, |
| very_long_argument2 |
| ): |
| pass |
| |
| x = Fooey() |
| assert x.a == 1 |
| """, |
| exclude="method_to_exclude", |
| ) |
| assert parser.statements == {1, 2, 3, 11, 12} |
| |
| def test_excluding_class(self) -> None: |
| parser = self.parse_text( |
| """\ |
| class Fooey: # nocover |
| def __init__(self): |
| self.a = 1 |
| |
| def foo(self): |
| return self.a |
| |
| x = 1 |
| assert x == 1 |
| """, |
| ) |
| assert parser.statements == {8, 9} |
| |
| def test_excludes_non_ascii(self) -> None: |
| parser = self.parse_text( |
| """\ |
| # coding: utf-8 |
| a = 1; b = 2 |
| |
| if len([]): |
| a = 5 # ✘cover |
| """, |
| exclude="✘cover", |
| ) |
| assert parser.statements == {2, 4} |
| |
| def test_no_exclude_at_all(self) -> None: |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| if fooey: |
| a = 3 |
| else: |
| a = 5 |
| b = 6 |
| """, |
| exclude="", |
| ) |
| assert parser.exit_counts() == {1: 1, 2: 2, 3: 1, 5: 1, 6: 1} |
| |
| def test_formfeed(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/461 |
| parser = self.parse_text( |
| """\ |
| x = 1 |
| assert len([]) == 0, ( |
| "This won't happen %s" % ("hello",) |
| ) |
| \f |
| x = 6 |
| assert len([]) == 0, ( |
| "This won't happen %s" % ("hello",) |
| ) |
| """, |
| exclude="assert", |
| ) |
| assert parser.statements == {1, 6} |
| |
| def test_decorator_pragmas(self) -> None: |
| parser = self.parse_text("""\ |
| # 1 |
| |
| @foo(3) # nocover |
| @bar |
| def func(x, y=5): |
| return 6 |
| |
| class Foo: # this is the only statement. |
| '''9''' |
| @foo # nocover |
| def __init__(self): |
| '''12''' |
| return 13 |
| |
| @foo( # nocover |
| 16, |
| 17, |
| ) |
| def meth(self): |
| return 20 |
| |
| @foo( # nocover |
| 23 |
| ) |
| def func(x=25): |
| return 26 |
| """) |
| raw_statements = {3, 4, 5, 6, 8, 9, 10, 11, 13, 15, 16, 17, 19, 20, 22, 23, 25, 26} |
| assert parser.raw_statements == raw_statements |
| assert parser.statements == {8} |
| |
| def test_decorator_pragmas_with_colons(self) -> None: |
| # A colon in a decorator expression would confuse the parser, |
| # ending the exclusion of the decorated function. |
| parser = self.parse_text("""\ |
| @decorate(X) # nocover |
| @decorate("Hello"[2]) |
| def f(): |
| x = 4 |
| |
| @decorate(X) # nocover |
| @decorate("Hello"[:7]) |
| def g(): |
| x = 9 |
| """) |
| raw_statements = {1, 2, 3, 4, 6, 7, 8, 9} |
| assert parser.raw_statements == raw_statements |
| assert parser.statements == set() |
| |
| def test_class_decorator_pragmas(self) -> None: |
| parser = self.parse_text("""\ |
| class Foo(object): |
| def __init__(self): |
| self.x = 3 |
| |
| @foo # nocover |
| class Bar(object): |
| def __init__(self): |
| self.x = 8 |
| """) |
| assert parser.raw_statements == {1, 2, 3, 5, 6, 7, 8} |
| assert parser.statements == {1, 2, 3} |
| |
| def test_over_exclusion_bug1779(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/1779 |
| parser = self.parse_text("""\ |
| import abc |
| |
| class MyProtocol: # nocover 3 |
| @abc.abstractmethod # nocover 4 |
| def my_method(self) -> int: |
| ... # 6 |
| |
| def function() -> int: |
| return 9 |
| """) |
| assert parser.raw_statements == {1, 3, 4, 5, 6, 8, 9} |
| assert parser.statements == {1, 8, 9} |
| |
| def test_multiline_exclusion_single_line(self) -> None: |
| regex = r"print\('.*'\)" |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| print('Hello, world!') |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {2} |
| assert parser.raw_statements == {1, 2} |
| assert parser.statements == {1} |
| |
| def test_multiline_exclusion_suite(self) -> None: |
| # A multi-line exclusion that matches a colon line still excludes the entire block. |
| regex = r"if T:\n\s+print\('Hello, world!'\)" |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| if T: |
| print('Hello, world!') |
| print('This is a multiline regex test.') |
| a = 5 |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {2, 3} |
| assert parser.raw_statements == {1, 2, 3, 4, 5} |
| assert parser.statements == {1, 5} |
| |
| def test_multiline_exclusion_no_match(self) -> None: |
| regex = r"nonexistent" |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| print('Hello, world!') |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == set() |
| assert parser.raw_statements == {1, 2} |
| assert parser.statements == {1, 2} |
| |
| def test_multiline_exclusion_no_source(self) -> None: |
| regex = r"anything" |
| parser = PythonParser(text="", filename="dummy.py", exclude=regex) |
| assert parser.lines_matching(regex) == set() |
| assert parser.raw_statements == set() |
| assert parser.statements == set() |
| |
| def test_multiline_exclusion_all_lines_must_match(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/996 |
| regex = r"except ValueError:\n\s*print\('false'\)" |
| parser = self.parse_text( |
| """\ |
| try: |
| a = 2 |
| print('false') |
| except ValueError: |
| print('false') |
| except ValueError: |
| print('something else') |
| except IndexError: |
| print('false') |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {4, 5} |
| assert parser.raw_statements == {1, 2, 3, 4, 5, 6, 7, 8, 9} |
| assert parser.statements == {1, 2, 3, 6, 7, 8, 9} |
| |
| def test_multiline_exclusion_multiple_matches(self) -> None: |
| regex = r"print\('.*'\)\n\s+. = \d" |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| print('Hello, world!') |
| a = 5 |
| def bar(): |
| print('Hello again!') |
| b = 6 |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {2, 3, 5, 6} |
| assert parser.raw_statements == {1, 2, 3, 4, 5, 6} |
| assert parser.statements == {1, 4} |
| |
| def test_multiline_exclusion_suite2(self) -> None: |
| regex = r"print\('Hello, world!'\)\n\s+if T:" |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| print('Hello, world!') |
| if T: |
| print('This is a test.') |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {2, 3} |
| assert parser.raw_statements == {1, 2, 3, 4} |
| assert parser.statements == {1} |
| |
| def test_multiline_exclusion_match_all(self) -> None: |
| regex = ( |
| r"def foo\(\):\n\s+print\('Hello, world!'\)\n" |
| + r"\s+if T:\n\s+print\('This is a test\.'\)" |
| ) |
| parser = self.parse_text( |
| """\ |
| def foo(): |
| print('Hello, world!') |
| if T: |
| print('This is a test.') |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {1, 2, 3, 4} |
| assert parser.raw_statements == {1, 2, 3, 4} |
| assert parser.statements == set() |
| |
| def test_multiline_exclusion_block(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/1803 |
| regex = "# no cover: start(?s:.)*?# no cover: stop" |
| parser = self.parse_text( |
| """\ |
| a = my_function1() |
| if debug: |
| msg = "blah blah" |
| # no cover: start |
| log_message(msg, a) |
| b = my_function2() |
| # no cover: stop |
| count_this() |
| # no cover: start |
| but_not_this() |
| # no cover: stop |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {4, 5, 6, 7, 9, 10, 11} |
| assert parser.raw_statements == {1, 2, 3, 5, 6, 8, 10} |
| assert parser.statements == {1, 2, 3, 8} |
| |
| def test_multiline_exclusion_block2(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/1797 |
| regex = r"case _:\n\s+assert_never\(" |
| parser = self.parse_text( |
| """\ |
| match something: |
| case type_1(): |
| logic_1() |
| case type_2(): |
| logic_2() |
| case _: |
| assert_never(something) |
| match something: |
| case type_1(): |
| logic_1() |
| case type_2(): |
| logic_2() |
| case _: |
| print("Default case") |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {6, 7} |
| assert parser.raw_statements == {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14} |
| assert parser.statements == {1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14} |
| |
| def test_multiline_exclusion_block3(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/1741 |
| # This will only work if there's exactly one return statement in the rest of the function |
| regex = r"# no cover: to return(?s:.)*?return" |
| parser = self.parse_text( |
| """\ |
| def my_function(args, j): |
| if args.command == Commands.CMD.value: |
| return cmd_handler(j, args) |
| # no cover: to return |
| print(f"Command '{args.command}' was not handled.", file=sys.stderr) |
| parser.print_help(file=sys.stderr) |
| |
| return os.EX_USAGE |
| print("not excluded") |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {4, 5, 6, 7, 8} |
| assert parser.raw_statements == {1, 2, 3, 5, 6, 8, 9} |
| assert parser.statements == {1, 2, 3, 9} |
| |
| def test_multiline_exclusion_whole_source(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/118 |
| regex = r"\A(?s:.*# pragma: exclude file.*)\Z" |
| parser = self.parse_text( |
| """\ |
| import coverage |
| # pragma: exclude file |
| def the_void() -> None: |
| if "py" not in __file__: |
| print("Not a Python file.") |
| print("Everything here is excluded.") |
| |
| return |
| print("Excluded too") |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} |
| assert parser.raw_statements == {1, 3, 4, 5, 6, 8, 9} |
| assert parser.statements == set() |
| |
| def test_multiline_exclusion_from_marker(self) -> None: |
| # https://github.com/coveragepy/coveragepy/issues/118 |
| regex = r"# pragma: rest of file(?s:.)*\Z" |
| parser = self.parse_text( |
| """\ |
| import coverage |
| # pragma: rest of file |
| def the_void() -> None: |
| if "py" not in __file__: |
| print("Not a Python file.") |
| print("Everything here is excluded.") |
| |
| return |
| print("Excluded too") |
| """, |
| regex, |
| ) |
| assert parser.lines_matching(regex) == {2, 3, 4, 5, 6, 7, 8, 9, 10} |
| assert parser.raw_statements == {1, 3, 4, 5, 6, 8, 9} |
| assert parser.statements == {1} |
| |
| |
| class ParserMissingArcDescriptionTest(PythonParserTestBase): |
| """Tests for PythonParser.missing_arc_description.""" |
| |
| def test_missing_arc_description(self) -> None: |
| # This code is never run, so the actual values don't matter. |
| parser = self.parse_text("""\ |
| if x: |
| print(2) |
| print(3) |
| |
| def func5(): |
| for x in range(6): |
| if x == 7: |
| break |
| |
| def func10(): |
| while something(11): |
| thing(12) |
| more_stuff(13) |
| """) |
| expected = "line 1 didn't jump to line 2 because the condition on line 1 was never true" |
| assert expected == parser.missing_arc_description(1, 2) |
| expected = "line 1 didn't jump to line 3 because the condition on line 1 was always true" |
| assert expected == parser.missing_arc_description(1, 3) |
| expected = ( |
| "line 6 didn't return from function 'func5' " |
| + "because the loop on line 6 didn't complete" |
| ) |
| assert expected == parser.missing_arc_description(6, -5) |
| expected = "line 6 didn't jump to line 7 because the loop on line 6 never started" |
| assert expected == parser.missing_arc_description(6, 7) |
| expected = "line 11 didn't jump to line 12 because the condition on line 11 was never true" |
| assert expected == parser.missing_arc_description(11, 12) |
| expected = ( |
| "line 11 didn't jump to line 13 " + "because the condition on line 11 was always true" |
| ) |
| assert expected == parser.missing_arc_description(11, 13) |
| |
| def test_missing_arc_descriptions_for_exceptions(self) -> None: |
| parser = self.parse_text("""\ |
| try: |
| pass |
| except ZeroDivideError: |
| print("whoops") |
| except ValueError: |
| print("yikes") |
| """) |
| expected = ( |
| "line 3 didn't jump to line 4 " + "because the exception caught by line 3 didn't happen" |
| ) |
| assert expected == parser.missing_arc_description(3, 4) |
| expected = ( |
| "line 5 didn't jump to line 6 " + "because the exception caught by line 5 didn't happen" |
| ) |
| assert expected == parser.missing_arc_description(5, 6) |
| |
| |
| class MatchCaseMissingArcDescriptionTest(PythonParserTestBase): |
| """Missing arc descriptions for match/case.""" |
| |
| def test_match_case(self) -> None: |
| parser = self.parse_text("""\ |
| match command.split(): |
| case ["go", direction] if direction in "nesw": # 2 |
| match = f"go: {direction}" |
| case ["go", _]: # 4 |
| match = "no go" |
| print(match) # 6 |
| """) |
| assert parser.missing_arc_description(2, 3) == ( |
| "line 2 didn't jump to line 3 because the pattern on line 2 never matched" |
| ) |
| assert parser.missing_arc_description(2, 4) == ( |
| "line 2 didn't jump to line 4 because the pattern on line 2 always matched" |
| ) |
| assert parser.missing_arc_description(4, 6) == ( |
| "line 4 didn't jump to line 6 because the pattern on line 4 always matched" |
| ) |
| |
| def test_final_wildcard(self) -> None: |
| parser = self.parse_text("""\ |
| match command.split(): |
| case ["go", direction] if direction in "nesw": # 2 |
| match = f"go: {direction}" |
| case _: # 4 |
| match = "no go" |
| print(match) # 6 |
| """) |
| assert parser.missing_arc_description(2, 3) == ( |
| "line 2 didn't jump to line 3 because the pattern on line 2 never matched" |
| ) |
| assert parser.missing_arc_description(2, 4) == ( |
| "line 2 didn't jump to line 4 because the pattern on line 2 always matched" |
| ) |
| # 4-6 isn't a possible arc, so the description is generic. |
| assert parser.missing_arc_description(4, 6) == "line 4 didn't jump to line 6" |
| |
| def test_missing_arc_descriptions_bug1775(self) -> None: |
| # Bug: the `if x == 2:` line was marked partial with a message of: |
| # line 6 didn't return from function 'func', because the return on line 4 wasn't executed |
| # At some point it changed to "didn't jump to the function exit," which |
| # is close enough. These situations are hard to describe precisely. |
| parser = self.parse_text("""\ |
| def func(): |
| x = 2 |
| try: |
| return 4 |
| finally: |
| if x == 2: # line 6 |
| print("x is 2") |
| |
| func() |
| """) |
| assert parser.missing_arc_description(6, -1) == "line 6 didn't jump to the function exit" |
| |
| |
| class ParserFileTest(CoverageTest): |
| """Tests for coverage.py's code parsing from files.""" |
| |
| def parse_file(self, filename: str) -> PythonParser: |
| """Parse `text` as source, and return the `PythonParser` used.""" |
| parser = PythonParser(filename=filename, exclude="nocover") |
| parser.parse_source() |
| return parser |
| |
| @pytest.mark.parametrize( |
| "slug, newline", |
| [ |
| ("unix", "\n"), |
| ("dos", "\r\n"), |
| ("mac", "\r"), |
| ], |
| ) |
| def test_line_endings(self, slug: str, newline: str) -> None: |
| text = """\ |
| # check some basic branch counting |
| class Foo: |
| def foo(self, a): |
| if a: |
| return 5 |
| else: |
| return 7 |
| |
| class Bar: |
| pass |
| """ |
| counts = {2: 1, 3: 1, 4: 2, 5: 1, 7: 1, 9: 1, 10: 1} |
| fname = slug + ".py" |
| self.make_file(fname, text, newline=newline) |
| parser = self.parse_file(fname) |
| assert parser.exit_counts() == counts, f"Wrong for {fname!r}" |
| |
| def test_encoding(self) -> None: |
| self.make_file( |
| "encoded.py", |
| """\ |
| coverage = "\xe7\xf6v\xear\xe3g\xe9" |
| """, |
| ) |
| parser = self.parse_file("encoded.py") |
| assert parser.exit_counts() == {1: 1} |
| |
| def test_missing_line_ending(self) -> None: |
| # Test that the set of statements is the same even if a final |
| # multi-line statement has no final newline. |
| # https://github.com/coveragepy/coveragepy/issues/293 |
| |
| self.make_file( |
| "normal.py", |
| """\ |
| out, err = some_module.some_function( |
| ["my data", "-c", "pass"], |
| arg1=some_module.NAME, |
| arg2=some_module.OTHER_NAME).function() |
| """, |
| ) |
| |
| parser = self.parse_file("normal.py") |
| assert parser.statements == {1} |
| |
| self.make_file( |
| "abrupt.py", |
| """\ |
| out, err = some_module.some_function( |
| ["my data", "-c", "pass"], |
| arg1=some_module.NAME, |
| arg2=some_module.OTHER_NAME).function()""", |
| ) # no final newline. |
| |
| # Double-check that some test helper wasn't being helpful. |
| with open("abrupt.py", encoding="utf-8") as f: |
| assert f.read()[-1] == ")" |
| |
| parser = self.parse_file("abrupt.py") |
| assert parser.statements == {1} |
| |
| def test_os_error(self) -> None: |
| self.make_file("cant-read.py", "BOOM!") |
| msg = "No source for code: 'cant-read.py': Fake!" |
| with pytest.raises(NoSource, match=re.escape(msg)): |
| with mock.patch("coverage.python.read_python_source", side_effect=OSError("Fake!")): |
| PythonParser(filename="cant-read.py") |
| |
| |
| @pytest.mark.parametrize( |
| ["expr", "ret"], |
| [ |
| ("True", (True, True)), |
| ("False", (True, False)), |
| ("1", (True, True)), |
| ("0", (True, False)), |
| ("__debug__", (True, True)), |
| ("not __debug__", (True, False)), |
| ("not(__debug__)", (True, False)), |
| ("-__debug__", (False, False)), |
| ("__debug__ or True", (True, True)), |
| ("__debug__ + True", (False, False)), |
| ("x", (False, False)), |
| ("__debug__ or debug", (False, False)), |
| ], |
| ) |
| def test_is_constant_test_expr(expr: str, ret: tuple[bool, bool]) -> None: |
| node = ast.parse(expr, mode="eval").body |
| print(ast.dump(node, indent=4)) |
| assert is_constant_test_expr(node) == ret |
| |
| |
| class MultilineMapTest(CoverageTest): |
| """Tests of multiline_map_from_text.""" |
| |
| run_in_temp_dir = False |
| |
| def multiline_map(self, text: str) -> dict[TLineNo, TLineNo]: |
| """Compute the multiline map of dedented `text`.""" |
| return multiline_map_from_text(textwrap.dedent(text)) |
| |
| def test_single_line_statements_have_no_entries(self) -> None: |
| assert ( |
| self.multiline_map("""\ |
| a = 1 |
| b = 2; c = 3 |
| # a comment |
| |
| def f(x): |
| return x |
| """) |
| == {} |
| ) |
| |
| def test_parenthesized_expression(self) -> None: |
| assert self.multiline_map("""\ |
| x = ( |
| 1 + |
| 2 |
| ) |
| y = 5 |
| """) == {1: 1, 2: 1, 3: 1, 4: 1} |
| |
| def test_backslash_continuation(self) -> None: |
| assert self.multiline_map("""\ |
| total = 1 + \\ |
| 2 |
| """) == {1: 1, 2: 1} |
| |
| def test_triple_quoted_string(self) -> None: |
| assert self.multiline_map("""\ |
| s = '''one |
| two |
| three''' |
| """) == {1: 1, 2: 1, 3: 1} |
| |
| def test_multiline_signature(self) -> None: |
| assert self.multiline_map("""\ |
| def f( |
| a, |
| b, |
| ): |
| return a + b |
| """) == {1: 1, 2: 1, 3: 1, 4: 1} |
| |
| def test_multiline_if_header(self) -> None: |
| assert self.multiline_map("""\ |
| if (a and |
| b): |
| c = 1 |
| """) == {1: 1, 2: 1} |
| |
| def test_blank_and_comment_lines_inside_statement(self) -> None: |
| # Lines inside a multi-line statement belong to it, even blank lines |
| # and comment lines. |
| assert self.multiline_map("""\ |
| x = [ |
| 1, |
| |
| # two comes next |
| 2, |
| ] |
| """) == {lineno: 1 for lineno in range(1, 7)} |
| |
| def test_statements_map_to_their_own_starts(self) -> None: |
| assert self.multiline_map("""\ |
| a = (1 + |
| 2) |
| b = 3 |
| c = (4 + |
| 5) |
| """) == {1: 1, 2: 1, 4: 4, 5: 4} |
| |
| def test_unparsable_text_raises(self) -> None: |
| with pytest.raises(tokenize.TokenError): |
| multiline_map_from_text("x = (\n") |
| |
| @pytest.mark.parametrize( |
| "text", |
| [ |
| """\ |
| a = 1 |
| b = 2 |
| """, |
| """\ |
| x = ( |
| 1 + |
| 2 |
| ) |
| y = 5 |
| """, |
| """\ |
| def f( |
| a, |
| b=[1, |
| 2], |
| ): |
| return (a + |
| b) |
| """, |
| """\ |
| @decorator( |
| arg, |
| ) |
| def f(): |
| pass |
| """, |
| """\ |
| if (a and |
| b): |
| c = (1, |
| 2) |
| """, |
| """\ |
| with (open('a') as fa, |
| open('b') as fb): |
| pass |
| """, |
| """\ |
| s = f'''one {x |
| + 1} two |
| three''' |
| t = 4 |
| """, |
| """\ |
| class C( |
| Base, |
| ): |
| attr = 1 |
| """, |
| """\ |
| result = [x |
| for x in items |
| if x > 0 |
| ] |
| """, |
| """\ |
| match (command, |
| arg): |
| case (1, 2): |
| pass |
| """, |
| """\ |
| total = 1 + \\ |
| 2 + \\ |
| 3 |
| """, |
| ], |
| ) |
| def test_agrees_with_python_parser(self, text: str) -> None: |
| # PythonParser._raw_parse gets its multiline map from the same code, |
| # but through a different path (tokenizing to a list first). The two |
| # must never drift apart: the sys.monitoring core uses this map to |
| # attribute branch arcs to the lines that reports are keyed by. |
| parser = PythonParser(text=textwrap.dedent(text)) |
| parser.parse_source() |
| assert multiline_map_from_text(text) == parser.multiline_map |
