kodjo/Sheerka-Old
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Working on #48 : Working

Browse Source
This commit is contained in:
Kodjo Sossouvi
2021-03-11 16:13:55 +01:00
parent 30c99b2d67
commit e303b32eb9
8 changed files with 186 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/parsers/test_LogicalOperatorParser.py
+25 -57
View File
@@ -7,11 +7,11 @@ from core.concept import Concept, DoNotResolve
from core.rule import Rule
from core.sheerka.services.SheerkaExecute import ParserInput
from core.tokenizer import TokenKind
from parsers.BaseExpressionParser import TrueifyVisitor, IsAQuestionVisitor, AndNode, LeftPartNotFoundError, \
ParenthesisMismatchError
from parsers.BaseParser import UnexpectedEofParsingError, UnexpectedTokenParsingError
from parsers.LogicalOperatorParser import LogicalOperatorParser
from parsers.PythonParser import PythonNode
from parsers.BaseExpressionParser import TrueifyVisitor, IsAQuestionVisitor, AndNode, LeftPartNotFoundError, \
ParenthesisMismatchError
from sheerkarete.network import ReteNetwork
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.parsers.parsers_utils import compute_expected_array, resolve_test_concept, EXPR, OR, AND, NOT, \
@@ -90,64 +90,31 @@ class TestLogicalOperatorParser(TestUsingMemoryBasedSheerka):
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
def test_i_can_detect_unbalanced_parenthesis(self):
@pytest.mark.parametrize("expression, expected_error, parenthesis_type, index", [
("(", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 0),
(")", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 0),
("one and two(", BuiltinConcepts.ERROR, TokenKind.LPAR, 11),
("one (", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 4),
("one (and", BuiltinConcepts.ERROR, TokenKind.LPAR, 4),
("one and two)", BuiltinConcepts.ERROR, TokenKind.RPAR, 11),
("one )", BuiltinConcepts.ERROR, TokenKind.RPAR, 4),
("one ) and", BuiltinConcepts.ERROR, TokenKind.RPAR, 4),
])
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("("))
res = parser.parse(context, ParserInput(expression))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
assert isinstance(res.body.reason[0], UnexpectedTokenParsingError)
assert res.body.reason[0].token.type == TokenKind.EOF
assert res.body.reason[0].expected_tokens == [TokenKind.RPAR]
res = parser.parse(context, ParserInput(")"))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
assert isinstance(res.body.reason[0], UnexpectedTokenParsingError)
assert res.body.reason[0].token.type == TokenKind.RPAR
assert res.body.reason[0].expected_tokens == []
res = parser.parse(context, ParserInput("one and two("))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
assert isinstance(res.body.body[0], ParenthesisMismatchError)
assert res.body.body[0].token.type == TokenKind.LPAR
assert res.body.body[0].token.index == 11
res = parser.parse(context, ParserInput("one ("))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
assert isinstance(res.body.reason[0], ParenthesisMismatchError)
assert res.body.reason[0].token.type == TokenKind.LPAR
assert res.body.reason[0].token.index == 4
res = parser.parse(context, ParserInput("one (and"))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
assert isinstance(res.body.body[0], ParenthesisMismatchError)
assert res.body.body[0].token.type == TokenKind.LPAR
assert res.body.body[0].token.index == 4
res = parser.parse(context, ParserInput("one and two)"))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
assert res.body.body[0].token.type == TokenKind.RPAR
assert res.body.body[0].expected_tokens == []
res = parser.parse(context, ParserInput("one )"))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
assert res.body.body[0].token.type == TokenKind.RPAR
assert res.body.body[0].expected_tokens == []
res = parser.parse(context, ParserInput("one ) and"))
assert not res.status
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
assert res.body.body[0].token.type == TokenKind.RPAR
assert res.body.body[0].expected_tokens == []
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_empty_expression(self):
sheerka, context, parser = self.init_parser()
@@ -444,6 +411,7 @@ class TestLogicalOperatorParser(TestUsingMemoryBasedSheerka):
resolved_expected = PythonNode(python_source, ast_, trimmed_source)
assert sheerka.objvalue(current_ret) == resolved_expected
@pytest.mark.skip
@pytest.mark.parametrize("expression, expected_conditions, test_obj", [
(
"__ret",
tests/parsers/test_RelationalOperatorParser.py
+15 -18
View File
@@ -24,28 +24,25 @@ class TestRelationalOperatorParser(TestUsingMemoryBasedSheerka):
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)"))),
("var_name", EXPR("var_name")),
("var_name.attr", EXPR("var_name.attr")),
("var_name.attr.get_value(x)", EXPR("var_name.attr.get_value(x)")),
("var_name.attr == 10", EQ(EXPR("var_name.attr"), EXPR("10"))),
("var_name.attr != 10", NEQ(EXPR("var_name.attr"), EXPR("10"))),
("var_name.attr > 10", GT(EXPR("var_name.attr"), EXPR("10"))),
("var_name.attr >= 10", GTE(EXPR("var_name.attr"), EXPR("10"))),
("var_name.attr < 10", LT(EXPR("var_name.attr"), EXPR("10"))),
("var_name.attr <= 10", LTE(EXPR("var_name.attr"), EXPR("10"))),
("var_name.attr in (a, b)", IN(EXPR("var_name.attr"), EXPR("a, b"))),
("var_name.attr not in (a, b)", NIN(EXPR("var_name.attr"), EXPR("a, b"))),
("var1.attr1 == var2.attr2", EQ(EXPR("var1.attr1"), EXPR("var2.attr2"))),
("var1.attr1 == (var2.attr2)", EQ(EXPR("var1.attr1"), EXPR("var2.attr2"))),
#("var_name.attr in (a.b, b.c)", IN(EXPR("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")))
("(var_name.attr != var_name2.attr2)", NEQ(EXPR("var_name.attr"), EXPR("var_name2.attr2")))
])
def test_i_can_parse_simple_expressions(self, expression, expected):
sheerka, context, parser = self.init_parser()