98 lines
4.9 KiB
Python
98 lines
4.9 KiB
Python
import pytest
|
|
|
|
from core.builtin_concepts_ids import BuiltinConcepts
|
|
from core.sheerka.services.SheerkaExecute import ParserInput
|
|
from core.tokenizer import TokenKind
|
|
from parsers.BaseParser import UnexpectedTokenParsingError
|
|
from parsers.RelationalOperatorParser import RelationalOperatorParser
|
|
from parsers.expressions import ParenthesisMismatchError
|
|
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
|
from tests.parsers.parsers_utils import get_expr_node_from_test_node, VAR, EXPR, EQ, NEQ, GT, GTE, LT, LTE, IN, NIN
|
|
|
|
|
|
class TestRelationalOperatorParser(TestUsingMemoryBasedSheerka):
|
|
def init_parser(self):
|
|
sheerka, context = self.init_concepts()
|
|
parser = RelationalOperatorParser()
|
|
return sheerka, context, parser
|
|
|
|
def test_i_can_detect_empty_expression(self):
|
|
sheerka, context, parser = self.init_parser()
|
|
res = parser.parse(context, ParserInput(""))
|
|
|
|
assert not res.status
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.IS_EMPTY)
|
|
|
|
@pytest.mark.parametrize("expression, expected", [
|
|
("var_name", VAR("var_name")),
|
|
("var_name.attr", VAR("var_name.attr")),
|
|
("var_name .attr", VAR("var_name.attr", source="var_name .attr")),
|
|
("var_name. attr", VAR("var_name.attr", source="var_name. attr")),
|
|
("var_name . attr", VAR("var_name.attr", source="var_name . attr")),
|
|
("var_name.attr.get_value(x)", VAR("var_name.attr.get_value(x)")),
|
|
("var_name.attr == 10", EQ(VAR("var_name.attr"), EXPR("10"))),
|
|
("var_name.attr != 10", NEQ(VAR("var_name.attr"), EXPR("10"))),
|
|
("var_name.attr > 10", GT(VAR("var_name.attr"), EXPR("10"))),
|
|
("var_name.attr >= 10", GTE(VAR("var_name.attr"), EXPR("10"))),
|
|
("var_name.attr < 10", LT(VAR("var_name.attr"), EXPR("10"))),
|
|
("var_name.attr <= 10", LTE(VAR("var_name.attr"), EXPR("10"))),
|
|
("var_name.attr in (a, b)", IN(VAR("var_name.attr"), EXPR("a, b"))),
|
|
("var_name.attr not in (a, b)", NIN(VAR("var_name.attr"), EXPR("a, b"))),
|
|
("var1.attr1 == var2.attr2", EQ(VAR("var1.attr1"), VAR("var2.attr2"))),
|
|
("var1.attr1 == (var2.attr2)", EQ(VAR("var1.attr1"), VAR("var2.attr2"))),
|
|
# ("var_name.attr in (a.b, b.c)", IN(VAR("var_name.attr"), PAREN(EXPR("a.b, b.c"), source="(a.b, b.c)"))),
|
|
|
|
("not a var identifier", EXPR("not a var identifier")),
|
|
("func()", EXPR("func()")),
|
|
#("func(a, not an identifier, x >5)", EXPR("func(a, not an identifier, x >5)")),
|
|
("(var_name.attr != var_name2.attr2)", NEQ(VAR("var_name.attr"), VAR("var_name2.attr2")))
|
|
])
|
|
def test_i_can_parse_simple_expressions(self, expression, expected):
|
|
sheerka, context, parser = self.init_parser()
|
|
expected = get_expr_node_from_test_node(expression, expected)
|
|
|
|
res = parser.parse(context, ParserInput(expression))
|
|
parser_result = res.body
|
|
parsed_expr = parser_result.body
|
|
|
|
assert res.status
|
|
assert res.who == parser.name
|
|
assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
|
|
assert parsed_expr == expected
|
|
|
|
@pytest.mark.parametrize("expression, expected_error, parenthesis_type, index", [
|
|
("(", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 0),
|
|
(")", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 0),
|
|
("something (", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 10),
|
|
# ("something )", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 10),
|
|
("something == (", BuiltinConcepts.ERROR, TokenKind.LPAR, 13),
|
|
("something == )", BuiltinConcepts.ERROR, TokenKind.RPAR, 13),
|
|
("something (==", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 10),
|
|
# ("something )==", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 10),
|
|
])
|
|
def test_i_can_detect_unbalanced_parenthesis(self, expression, expected_error, parenthesis_type, index):
|
|
sheerka, context, parser = self.init_parser()
|
|
|
|
res = parser.parse(context, ParserInput(expression))
|
|
assert not res.status
|
|
if expected_error == BuiltinConcepts.NOT_FOR_ME:
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
|
|
assert isinstance(res.body.reason[0], ParenthesisMismatchError)
|
|
assert res.body.reason[0].token.type == parenthesis_type
|
|
assert res.body.reason[0].token.index == index
|
|
else:
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
|
|
assert isinstance(res.body.body[0], ParenthesisMismatchError)
|
|
assert res.body.body[0].token.type == parenthesis_type
|
|
assert res.body.body[0].token.index == index
|
|
|
|
def test_i_can_detect_syntax_error(self):
|
|
sheerka, context, parser = self.init_parser()
|
|
|
|
expression = "var in a"
|
|
res = parser.parse(context, ParserInput(expression))
|
|
|
|
assert not res.status
|
|
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
|
|
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
|