| # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0 |
| # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt |
| |
| """Tests for coverage.py's code parsing.""" |
| |
| from __future__ import annotations |
| |
| import textwrap |
| |
| import pytest |
| |
| from coverage import env |
| from coverage.exceptions import NotPython |
| from coverage.parser import PythonParser |
| |
| from tests.coveragetest import CoverageTest |
| from tests.helpers import arcz_to_arcs, xfail_pypy38 |
| |
| |
| 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_generator_exit_counts(self) -> None: |
| # https://github.com/nedbat/coveragepy/issues/324 |
| parser = self.parse_text("""\ |
| def gen(input): |
| for n in inp: |
| yield (i * 2 for i in range(n)) |
| |
| list(gen([1,2,3])) |
| """) |
| assert parser.exit_counts() == { |
| 1:1, # def -> list |
| 2:2, # for -> yield; for -> exit |
| 3:2, # yield -> for; genexp exit |
| 5:1, # list -> exit |
| } |
| |
| 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:2, 4:1, 5:2, 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() == { |
| 1:0, 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 |
| """) |
| |
| expected_statements = {1, 2, 4, 5, 8, 9, 10} |
| expected_arcs = set(arcz_to_arcs(".1 14 45 58 89 9. .2 2. -8A A-8")) |
| expected_exits = {1: 1, 2: 1, 4: 1, 5: 1, 8: 1, 9: 1, 10: 1} |
| |
| if env.PYBEHAVIOR.docstring_only_function: |
| # 3.7 changed how functions with only docstrings are numbered. |
| expected_arcs.update(set(arcz_to_arcs("-46 6-4"))) |
| expected_exits.update({6: 1}) |
| |
| if env.PYBEHAVIOR.trace_decorator_line_again: |
| expected_arcs.update(set(arcz_to_arcs("54 98"))) |
| expected_exits.update({9: 2, 5: 2}) |
| |
| assert expected_statements == parser.statements |
| assert expected_arcs == parser.arcs() |
| assert expected_exits == parser.exit_counts() |
| |
| 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("]") |
| |
| |
| 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/nedbat/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} |
| parser = self.parse_text("""\ |
| def my_func( |
| super_long_input_argument_0=0, |
| super_long_input_argument_1=1, |
| super_long_input_argument_2=2): |
| pass |
| |
| def my_func_2(super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2): |
| pass |
| """, |
| exclude="my_func", |
| ) |
| assert parser.statements == set() |
| parser = self.parse_text("""\ |
| def my_func( |
| super_long_input_argument_0=0, |
| super_long_input_argument_1=1, |
| super_long_input_argument_2=2): |
| pass |
| |
| def my_func_2(super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2): |
| pass |
| """, |
| exclude="my_func_2", |
| ) |
| assert parser.statements == {1,5} |
| parser = self.parse_text("""\ |
| def my_func ( |
| super_long_input_argument_0=0, |
| super_long_input_argument_1=1, |
| super_long_input_argument_2=2): |
| pass |
| |
| def my_func_2 (super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2): |
| pass |
| """, |
| exclude="my_func_2", |
| ) |
| assert parser.statements == {1,5} |
| parser = self.parse_text("""\ |
| def my_func ( |
| super_long_input_argument_0=0, |
| super_long_input_argument_1=1, |
| super_long_input_argument_2=2): |
| pass |
| |
| def my_func_2 (super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2): |
| pass |
| """, |
| exclude="my_func", |
| ) |
| assert parser.statements == set() |
| parser = self.parse_text("""\ |
| def my_func \ |
| ( |
| super_long_input_argument_0=0, |
| super_long_input_argument_1=1 |
| ): |
| pass |
| |
| def my_func_2(super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2): |
| pass |
| """, |
| exclude="my_func_2", |
| ) |
| assert parser.statements == {1,5} |
| parser = self.parse_text("""\ |
| def my_func \ |
| ( |
| super_long_input_argument_0=0, |
| super_long_input_argument_1=1 |
| ): |
| pass |
| |
| def my_func_2(super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2): |
| pass |
| """, |
| exclude="my_func", |
| ) |
| assert parser.statements == set() |
| |
| def test_excluding_bug1713(self) -> None: |
| if env.PYVERSION >= (3, 10): |
| 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_formfeed(self) -> None: |
| # https://github.com/nedbat/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} |
| |
| @xfail_pypy38 |
| 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} |
| |
| @xfail_pypy38 |
| 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() |
| |
| @pytest.mark.xfail( |
| env.PYPY and env.PYVERSION[:2] == (3, 8), |
| reason="AST doesn't mark end of classes correctly", |
| ) |
| 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/nedbat/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/nedbat/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/nedbat/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 |
| """, regex) |
| assert parser.lines_matching(regex) == {4, 5, 6, 7} |
| assert parser.raw_statements == {1, 2, 3, 5, 6} |
| assert parser.statements == {1, 2, 3} |
| |
| @pytest.mark.skipif(not env.PYBEHAVIOR.match_case, reason="Match-case is new in 3.10") |
| def test_multiline_exclusion_block2(self) -> None: |
| # https://github.com/nedbat/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/nedbat/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/nedbat/coveragepy/issues/118 |
| regex = r"(?s)\A.*# 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/nedbat/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_small_callables(self) -> None: |
| parser = self.parse_text("""\ |
| callables = [ |
| lambda: 2, |
| (x for x in range(3)), |
| {x:1 for x in range(4)}, |
| {x for x in range(5)}, |
| ] |
| x = 7 |
| """) |
| expected = "line 2 didn't finish the lambda on line 2" |
| assert expected == parser.missing_arc_description(2, -2) |
| expected = "line 3 didn't finish the generator expression on line 3" |
| assert expected == parser.missing_arc_description(3, -3) |
| if env.PYBEHAVIOR.comprehensions_are_functions: |
| expected = "line 4 didn't finish the dictionary comprehension on line 4" |
| assert expected == parser.missing_arc_description(4, -4) |
| expected = "line 5 didn't finish the set comprehension on line 5" |
| assert expected == parser.missing_arc_description(5, -5) |
| |
| 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) |
| |
| def test_missing_arc_descriptions_for_finally(self) -> None: |
| parser = self.parse_text("""\ |
| def function(): |
| for i in range(2): |
| try: |
| if something(4): |
| break |
| elif something(6): |
| x = 7 |
| else: |
| if something(9): |
| continue |
| else: |
| continue |
| if also_this(13): |
| return 14 |
| else: |
| raise Exception(16) |
| finally: |
| this_thing(18) |
| that_thing(19) |
| """) |
| if env.PYBEHAVIOR.finally_jumps_back: |
| expected = "line 18 didn't jump to line 5 because the break on line 5 wasn't executed" |
| assert expected == parser.missing_arc_description(18, 5) |
| expected = "line 5 didn't jump to line 19 because the break on line 5 wasn't executed" |
| assert expected == parser.missing_arc_description(5, 19) |
| expected = ( |
| "line 18 didn't jump to line 10 " + |
| "because the continue on line 10 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(18, 10) |
| expected = ( |
| "line 10 didn't jump to line 2 " + |
| "because the continue on line 10 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(10, 2) |
| expected = ( |
| "line 18 didn't jump to line 14 " + |
| "because the return on line 14 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(18, 14) |
| expected = ( |
| "line 14 didn't return from function 'function' " + |
| "because the return on line 14 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(14, -1) |
| expected = ( |
| "line 18 didn't except from function 'function' " + |
| "because the raise on line 16 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(18, -1) |
| else: |
| expected = ( |
| "line 18 didn't jump to line 19 " + |
| "because the break on line 5 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(18, 19) |
| expected = ( |
| "line 18 didn't jump to line 2 " + |
| "because the continue on line 10 wasn't executed" + |
| " or " + |
| "the continue on line 12 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(18, 2) |
| expected = ( |
| "line 18 didn't except from function 'function' " + |
| "because the raise on line 16 wasn't executed" + |
| " or " + |
| "line 18 didn't return from function 'function' " + |
| "because the return on line 14 wasn't executed" |
| ) |
| assert expected == parser.missing_arc_description(18, -1) |
| |
| def test_missing_arc_descriptions_bug460(self) -> None: |
| parser = self.parse_text("""\ |
| x = 1 |
| d = { |
| 3: lambda: [], |
| 4: lambda: [], |
| } |
| x = 6 |
| """) |
| assert parser.missing_arc_description(2, -3) == "line 3 didn't finish the lambda on line 3" |
| |
| |
| @pytest.mark.skipif(not env.PYBEHAVIOR.match_case, reason="Match-case is new in 3.10") |
| 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" |
| |
| |
| 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/nedbat/coveragepy/issues/293 |
| |
| self.make_file("normal.py", """\ |
| out, err = subprocess.Popen( |
| [sys.executable, '-c', 'pass'], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE).communicate() |
| """) |
| |
| parser = self.parse_file("normal.py") |
| assert parser.statements == {1} |
| |
| self.make_file("abrupt.py", """\ |
| out, err = subprocess.Popen( |
| [sys.executable, '-c', 'pass'], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE).communicate()""") # no final newline. |
| |
| # Double-check that some test helper wasn't being helpful. |
| with open("abrupt.py") as f: |
| assert f.read()[-1] == ")" |
| |
| parser = self.parse_file("abrupt.py") |
| assert parser.statements == {1} |
