kodjo
89e1f20975
Fixed #130 : ArithmeticOperatorParser Fixed #129 : python_wrapper : create_namespace Fixed #128 : ExpressionParser: Cannot parse func(x) infixed concept 'xxx'
89 lines
3.9 KiB
Python
89 lines
3.9 KiB
Python
import pytest
|
|
|
|
from core.builtin_concepts_ids import BuiltinConcepts
|
|
from core.sheerka.services.SheerkaExecute import ParserInput
|
|
from core.tokenizer import Token, TokenKind
|
|
from parsers.BaseExpressionParser import ParenthesisMismatchError, end_parenthesis_mapping
|
|
from parsers.BaseParser import ErrorSink
|
|
from parsers.ListParser import ListParser
|
|
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
|
from tests.parsers.parsers_utils import EXPR, L_EXPR, get_expr_node_from_test_node
|
|
|
|
semi_colon = Token(TokenKind.SEMICOLON, ";", -1, -1, -1)
|
|
or_token = Token(TokenKind.IDENTIFIER, "or", -1, -1, -1)
|
|
|
|
|
|
class TestListParser(TestUsingMemoryBasedSheerka):
|
|
def init_parser(self, strict=True, sep=None):
|
|
sheerka, context = self.init_concepts()
|
|
parser = ListParser(strict, sep)
|
|
return sheerka, context, parser
|
|
|
|
@pytest.mark.parametrize("expression, sep, expected", [
|
|
("()", None, L_EXPR("(", ")")),
|
|
("(x , foo y,z)", None, L_EXPR("(", ")", EXPR("x"), EXPR("foo y"), EXPR("z"), source="(x , foo y,z)")),
|
|
("x , foo y,z", None, L_EXPR(None, None, EXPR("x"), EXPR("foo y"), EXPR("z"), source="x , foo y,z")),
|
|
("x", None, L_EXPR(None, None, EXPR("x"))),
|
|
("[x, foo y, z]", None, L_EXPR("[", "]", EXPR("x"), EXPR("foo y"), EXPR("z"))),
|
|
("{x, foo y, z}", None, L_EXPR("{", "}", EXPR("x"), EXPR("foo y"), EXPR("z"))),
|
|
("(x; y; z)", semi_colon, L_EXPR("(", ")", "x", "y", "z", sep=semi_colon, source="(x; y; z)")),
|
|
("x; y; z", semi_colon, L_EXPR(None, None, EXPR("x"), EXPR("y"), EXPR("z"), sep=semi_colon, source="x; y; z")),
|
|
("x or y or z", or_token,
|
|
L_EXPR(None, None, EXPR("x"), EXPR("y"), EXPR("z"), sep=or_token, source="x or y or z")),
|
|
])
|
|
def test_i_can_parse_expression(self, expression, sep, expected):
|
|
sheerka, context, parser = self.init_parser(strict=False, sep=sep)
|
|
|
|
expected = get_expr_node_from_test_node(expression, expected)
|
|
res = parser.parse(context, ParserInput(expression))
|
|
wrapper = res.body
|
|
expressions = res.body.body
|
|
|
|
assert res.status
|
|
assert sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
|
|
assert expressions == expected
|
|
|
|
@pytest.mark.parametrize("expression, expected", [
|
|
("()", L_EXPR("(", ")")),
|
|
("(a, b)", L_EXPR("(", ")", EXPR("a"), EXPR("b"))),
|
|
("a, b", None),
|
|
])
|
|
def test_parenthesis_are_mandatory_when_strict(self, expression, expected):
|
|
sheerka, context, parser = self.init_parser(strict=True)
|
|
res = parser.parse(context, ParserInput(expression))
|
|
|
|
if expected:
|
|
expected = get_expr_node_from_test_node(expression, expected)
|
|
assert res.status
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.PARSER_RESULT)
|
|
assert res.body.body == expected
|
|
else:
|
|
assert not res.status
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
|
|
|
|
@pytest.mark.parametrize("expression, starting", [
|
|
("(", TokenKind.LPAR),
|
|
("(x, y", TokenKind.LPAR),
|
|
("{x, y", TokenKind.LBRACE),
|
|
("[x, y", TokenKind.LBRACKET),
|
|
])
|
|
def test_i_cannot_parse_when_missing_trailing_parenthesis(self, expression, starting):
|
|
sheerka, context, parser = self.init_parser()
|
|
|
|
res = parser.parse(context, ParserInput(expression))
|
|
|
|
assert not res.status
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
|
|
assert res.body.body == [ParenthesisMismatchError(end_parenthesis_mapping[starting])]
|
|
|
|
def test_none_is_return_when_empty_parser_input(self):
|
|
sheerka, context, parser = self.init_parser()
|
|
|
|
parser_input = ParserInput(" ").reset()
|
|
parser_input.next_token()
|
|
error_sink = ErrorSink()
|
|
|
|
parsed = parser.parse_input(context, parser_input, error_sink)
|
|
|
|
assert parsed is None
|