VimPlug/parso
1
0
Fork 0
mirror of https://github.com/davidhalter/parso.git synced 2025-12-07 13:24:39 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove the dependency to unittest.

Browse Source
This commit is contained in:
Dave Halter
2017-05-17 14:29:55 -04:00
parent 2d8d3cc157
commit 799e99360c
2 changed files with 189 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
test/helpers.py
View File

@@ -1,13 +0,0 @@
"""
A helper module for testing, improves compatibility for testing (as
``jedi._compatibility``) as well as introducing helper functions.
"""
import sys
if sys.hexversion < 0x02070000:
import unittest2 as unittest
else:
import unittest
TestCase = unittest.TestCase

171
test/test_pgen2.py
View File

@@ -13,8 +13,6 @@ from parso.python import parse as _parse, load_grammar
from parso import ParserSyntaxError from parso import ParserSyntaxError
import pytest import pytest
from test.helpers import TestCase
def parse(code, version='3.4'): def parse(code, version='3.4'):
code = dedent(code) + "\n\n" code = dedent(code) + "\n\n"
@@ -22,19 +20,16 @@ def parse(code, version='3.4'):
return _parse(code, grammar=grammar, error_recovery=False) return _parse(code, grammar=grammar, error_recovery=False)
class TestDriver(TestCase): def test_formfeed():
def test_formfeed(self):
s = """print 1\n\x0Cprint 2\n""" s = """print 1\n\x0Cprint 2\n"""
t = parse(s, '2.7') t = parse(s, '2.7')
self.assertEqual(t.children[0].children[0].type, 'print_stmt') assert t.children[0].children[0].type == 'print_stmt'
self.assertEqual(t.children[1].children[0].type, 'print_stmt') assert t.children[1].children[0].type == 'print_stmt'
s = """1\n\x0C\x0C2\n""" s = """1\n\x0C\x0C2\n"""
t = parse(s, '2.7') t = parse(s, '2.7')
class GrammarTest(TestCase): def _invalid_syntax(code, **kwargs):
def invalid_syntax(self, code, **kwargs):
try: try:
parse(code, **kwargs) parse(code, **kwargs)
except ParserSyntaxError: except ParserSyntaxError:
@@ -43,23 +38,20 @@ class GrammarTest(TestCase):
raise AssertionError("Syntax shouldn't have been valid") raise AssertionError("Syntax shouldn't have been valid")
class TestMatrixMultiplication(GrammarTest): @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)') def test_matrix_multiplication_operator():
def test_matrix_multiplication_operator(self):
parse("a @ b", "3.5") parse("a @ b", "3.5")
parse("a @= b", "3.5") parse("a @= b", "3.5")
class TestYieldFrom(GrammarTest): def test_yield_from():
def test_yield_from(self):
parse("yield from x") parse("yield from x")
parse("(yield from x) + y") parse("(yield from x) + y")
self.invalid_syntax("yield from") _invalid_syntax("yield from")
class TestAsyncAwait(GrammarTest): @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)') def test_await_expr():
def test_await_expr(self):
parse("""async def foo(): parse("""async def foo():
await x await x
""", "3.5") """, "3.5")
@@ -80,109 +72,111 @@ class TestAsyncAwait(GrammarTest):
async def foo(): await x async def foo(): await x
""", "3.5") """, "3.5")
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
@pytest.mark.xfail(reason="acting like python 3.7") @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_await_expr_invalid(self): @pytest.mark.xfail(reason="acting like python 3.7")
self.invalid_syntax("await x", version="3.5") def test_await_expr_invalid():
self.invalid_syntax("""def foo(): _invalid_syntax("await x", version="3.5")
_invalid_syntax("""def foo():
await x""", version="3.5") await x""", version="3.5")
self.invalid_syntax("""def foo(): _invalid_syntax("""def foo():
def foo(): pass def foo(): pass
async def foo(): pass async def foo(): pass
await x await x
""", version="3.5") """, version="3.5")
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
@pytest.mark.xfail(reason="acting like python 3.7") @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_async_var(self): @pytest.mark.xfail(reason="acting like python 3.7")
def test_async_var():
parse("""async = 1""", "3.5") parse("""async = 1""", "3.5")
parse("""await = 1""", "3.5") parse("""await = 1""", "3.5")
parse("""def async(): pass""", "3.5") parse("""def async(): pass""", "3.5")
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_async_for(self): @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_async_for():
parse("""async def foo(): parse("""async def foo():
async for a in b: pass""", "3.5") async for a in b: pass""", "3.5")
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
@pytest.mark.xfail(reason="acting like python 3.7") @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_async_for_invalid(self): @pytest.mark.xfail(reason="acting like python 3.7")
self.invalid_syntax("""def foo(): def test_async_for_invalid():
_invalid_syntax("""def foo():
async for a in b: pass""", version="3.5") async for a in b: pass""", version="3.5")
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_async_with(self): @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
def test_async_with():
parse("""async def foo(): parse("""async def foo():
async with a: pass""", "3.5") async with a: pass""", "3.5")
@pytest.mark.skipif('sys.version_info[:2] < (3, 5)') @pytest.mark.skipif('sys.version_info[:2] < (3, 5)')
@pytest.mark.xfail(reason="acting like python 3.7") @pytest.mark.xfail(reason="acting like python 3.7")
def test_async_with_invalid(self): def test_async_with_invalid():
self.invalid_syntax("""def foo(): _invalid_syntax("""def foo():
async with a: pass""", version="3.5") async with a: pass""", version="3.5")
class TestRaiseChanges(GrammarTest): def test_raise_2x_style_1():
def test_2x_style_1(self):
parse("raise") parse("raise")
def test_2x_style_2(self): def test_raise_2x_style_2():
parse("raise E, V", version='2.7') parse("raise E, V", version='2.7')
def test_2x_style_3(self): def test_raise_2x_style_3():
parse("raise E, V, T", version='2.7') parse("raise E, V, T", version='2.7')
def test_2x_style_invalid_1(self): def test_raise_2x_style_invalid_1():
self.invalid_syntax("raise E, V, T, Z", version='2.7') _invalid_syntax("raise E, V, T, Z", version='2.7')
def test_3x_style(self): def test_raise_3x_style():
parse("raise E1 from E2") parse("raise E1 from E2")
def test_3x_style_invalid_1(self): def test_raise_3x_style_invalid_1():
self.invalid_syntax("raise E, V from E1") _invalid_syntax("raise E, V from E1")
def test_3x_style_invalid_2(self): def test_raise_3x_style_invalid_2():
self.invalid_syntax("raise E from E1, E2") _invalid_syntax("raise E from E1, E2")
def test_3x_style_invalid_3(self): def test_raise_3x_style_invalid_3():
self.invalid_syntax("raise from E1, E2") _invalid_syntax("raise from E1, E2")
def test_3x_style_invalid_4(self): def test_raise_3x_style_invalid_4():
self.invalid_syntax("raise E from") _invalid_syntax("raise E from")
# Adapted from Python 3's Lib/test/test_grammar.py:GrammarTests.testFuncdef # Adapted from Python 3's Lib/test/test_grammar.py:GrammarTests.testFuncdef
class TestFunctionAnnotations(GrammarTest): def test_annotation_1():
def test_1(self):
parse("""def f(x) -> list: pass""") parse("""def f(x) -> list: pass""")
def test_2(self): def test_annotation_2():
parse("""def f(x:int): pass""") parse("""def f(x:int): pass""")
def test_3(self): def test_annotation_3():
parse("""def f(*x:str): pass""") parse("""def f(*x:str): pass""")
def test_4(self): def test_annotation_4():
parse("""def f(**x:float): pass""") parse("""def f(**x:float): pass""")
def test_5(self): def test_annotation_5():
parse("""def f(x, y:1+2): pass""") parse("""def f(x, y:1+2): pass""")
def test_6(self): def test_annotation_6():
self.invalid_syntax("""def f(a, (b:1, c:2, d)): pass""") _invalid_syntax("""def f(a, (b:1, c:2, d)): pass""")
def test_7(self): def test_annotation_7():
self.invalid_syntax("""def f(a, (b:1, c:2, d), e:3=4, f=5, *g:6): pass""") _invalid_syntax("""def f(a, (b:1, c:2, d), e:3=4, f=5, *g:6): pass""")
def test_8(self): def test_annotation_8():
s = """def f(a, (b:1, c:2, d), e:3=4, f=5, s = """def f(a, (b:1, c:2, d), e:3=4, f=5,
*g:6, h:7, i=8, j:9=10, **k:11) -> 12: pass""" *g:6, h:7, i=8, j:9=10, **k:11) -> 12: pass"""
self.invalid_syntax(s) _invalid_syntax(s)
class TestExcept(GrammarTest): def test_except_new():
def test_new(self):
s = """ s = """
try: try:
x x
@@ -190,7 +184,7 @@ class TestExcept(GrammarTest):
y""" y"""
parse(s) parse(s)
def test_old(self): def test_except_old():
s = """ s = """
try: try:
x x
@@ -200,36 +194,33 @@ class TestExcept(GrammarTest):
# Adapted from Python 3's Lib/test/test_grammar.py:GrammarTests.testAtoms # Adapted from Python 3's Lib/test/test_grammar.py:GrammarTests.testAtoms
class TestSetLiteral(GrammarTest): def test_set_literal_1():
def test_1(self):
parse("""x = {'one'}""") parse("""x = {'one'}""")
def test_2(self): def test_set_literal_2():
parse("""x = {'one', 1,}""") parse("""x = {'one', 1,}""")
def test_3(self): def test_set_literal_3():
parse("""x = {'one', 'two', 'three'}""") parse("""x = {'one', 'two', 'three'}""")
def test_4(self): def test_set_literal_4():
parse("""x = {2, 3, 4,}""") parse("""x = {2, 3, 4,}""")
class TestNumericLiterals(GrammarTest): def test_new_octal_notation():
def test_new_octal_notation(self):
code = """0o7777777777777""" code = """0o7777777777777"""
if py_version >= 30: if py_version >= 30:
parse(code) parse(code)
else: else:
self.invalid_syntax(code) _invalid_syntax(code)
self.invalid_syntax("""0o7324528887""") _invalid_syntax("""0o7324528887""")
def test_new_binary_notation(self): def test_new_binary_notation():
parse("""0b101010""") parse("""0b101010""")
self.invalid_syntax("""0b0101021""") _invalid_syntax("""0b0101021""")
class TestClassDef(GrammarTest): def test_class_new_syntax():
def test_new_syntax(self):
parse("class B(t=7): pass") parse("class B(t=7): pass")
parse("class B(t, *args): pass") parse("class B(t, *args): pass")
parse("class B(t, **kwargs): pass") parse("class B(t, **kwargs): pass")
@@ -237,20 +228,20 @@ class TestClassDef(GrammarTest):
parse("class B(t, y=9, *args, **kwargs): pass") parse("class B(t, y=9, *args, **kwargs): pass")
class TestParserIdempotency(TestCase): def test_parser_idempotency_extended_unpacking():
"""A cut-down version of pytree_idempotency.py.""" """A cut-down version of pytree_idempotency.py."""
def test_extended_unpacking(self):
parse("a, *b, c = x\n") parse("a, *b, c = x\n")
parse("[*a, b] = x\n") parse("[*a, b] = x\n")
parse("(z, *y, w) = m\n") parse("(z, *y, w) = m\n")
parse("for *z, m in d: pass\n") parse("for *z, m in d: pass\n")
class TestLiterals(GrammarTest): @pytest.mark.skipif('sys.version_info[0] < 3')
# It's not possible to get the same result when using \xaa in Python 2/3, def test_multiline_bytes_literals():
# because it's treated differently. """
@pytest.mark.skipif('sys.version_info[0] < 3') It's not possible to get the same result when using \xaa in Python 2/3,
def test_multiline_bytes_literals(self): because it's treated differently.
"""
s = """ s = """
md5test(b"\xaa" * 80, md5test(b"\xaa" * 80,
(b"Test Using Larger Than Block-Size Key " (b"Test Using Larger Than Block-Size Key "
@@ -259,7 +250,7 @@ class TestLiterals(GrammarTest):
""" """
parse(s) parse(s)
def test_multiline_bytes_tripquote_literals(self): def test_multiline_bytes_tripquote_literals():
s = ''' s = '''
b""" b"""
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
@@ -268,8 +259,8 @@ class TestLiterals(GrammarTest):
''' '''
parse(s) parse(s)
@pytest.mark.skipif('sys.version_info[0] < 3') @pytest.mark.skipif('sys.version_info[0] < 3')
def test_multiline_str_literals(self): def test_multiline_str_literals():
s = """ s = """
md5test("\xaa" * 80, md5test("\xaa" * 80,
("Test Using Larger Than Block-Size Key " ("Test Using Larger Than Block-Size Key "