168 lines
8.0 KiB
Python
168 lines
8.0 KiB
Python
import pytest
|
|
|
|
from common.utils import unstr_concept
|
|
from conftest import NewOntology
|
|
from helpers import get_concepts
|
|
from parsers.BnfDefinitionParser import BnfDefinitionParser
|
|
from parsers.parser_utils import UnexpectedEof, UnexpectedToken
|
|
from parsers.peg_parser import ConceptExpression, OneOrMore, Optional, OrderedChoice, RegExMatch, Sequence, StrMatch, \
|
|
VariableExpression, ZeroOrMore
|
|
|
|
|
|
def _cexp(concept_str, rule_name=None):
|
|
concept_name, concept_id = unstr_concept(concept_str)
|
|
return ConceptExpression(concept_id, rule_name or concept_name)
|
|
|
|
|
|
@pytest.mark.parametrize("expression, expected", [
|
|
("'str'", StrMatch("str")),
|
|
("1", StrMatch("1")),
|
|
(" 1", StrMatch("1")),
|
|
(",", StrMatch(",")),
|
|
("r'str'", RegExMatch("str")),
|
|
("'foo'?", Optional(StrMatch("foo"))),
|
|
("'foo'*", ZeroOrMore(StrMatch("foo"))),
|
|
("'foo'+", OneOrMore(StrMatch("foo"))),
|
|
("1 | 2 | 3", OrderedChoice(StrMatch("1"), StrMatch("2"), StrMatch("3"))),
|
|
("1|2|3", OrderedChoice(StrMatch("1"), StrMatch("2"), StrMatch("3"))),
|
|
("1'|' 2 '|' 3", Sequence(StrMatch("1"), StrMatch("|"), StrMatch("2"), StrMatch("|"), StrMatch("3"))),
|
|
("1 2 'foo'", Sequence(StrMatch("1"), StrMatch("2"), StrMatch("foo"))),
|
|
("1 2 | 3 4+", OrderedChoice(
|
|
Sequence(StrMatch("1"), StrMatch("2")),
|
|
Sequence(StrMatch("3"), OneOrMore(StrMatch("4"))))),
|
|
("1 (2 | 3) 4+", Sequence(
|
|
StrMatch("1"),
|
|
OrderedChoice(StrMatch("2"), StrMatch("3")),
|
|
OneOrMore(StrMatch("4")))),
|
|
("(1|2)+", OneOrMore(OrderedChoice(StrMatch("1"), StrMatch("2")))),
|
|
("(1 2)+", OneOrMore(Sequence(StrMatch("1"), StrMatch("2")))),
|
|
("1 *", Sequence(StrMatch("1"), StrMatch("*"))),
|
|
("1 ?", Sequence(StrMatch("1"), StrMatch("?"))),
|
|
("1 +", Sequence(StrMatch("1"), StrMatch("+"))),
|
|
("(1|*) +", Sequence(OrderedChoice(StrMatch("1"), StrMatch("*")), StrMatch("+"))),
|
|
("1, :&", Sequence(StrMatch("1"), StrMatch(","), StrMatch(":"), StrMatch("&"))),
|
|
("(1 )", StrMatch("1")),
|
|
("'str'=var", StrMatch("str", rule_name="var")),
|
|
("'foo'?=var", Optional(StrMatch("foo"), rule_name="var")),
|
|
("('foo'?)=var", Optional(StrMatch("foo"), rule_name="var")),
|
|
("'foo'*=var", ZeroOrMore(StrMatch("foo"), rule_name="var")),
|
|
("('foo'*)=var", ZeroOrMore(StrMatch("foo"), rule_name="var")),
|
|
("'foo'+=var", OneOrMore(StrMatch("foo"), rule_name="var")),
|
|
("('foo'+)=var", OneOrMore(StrMatch("foo"), rule_name="var")),
|
|
("'foo'=var?", Optional(StrMatch("foo", rule_name="var"))),
|
|
("('foo'=var)?", Optional(StrMatch("foo", rule_name="var"))),
|
|
("'foo'=var*", ZeroOrMore(StrMatch("foo", rule_name="var"))),
|
|
("('foo'=var)*", ZeroOrMore(StrMatch("foo", rule_name="var"))),
|
|
("'foo'=var+", OneOrMore(StrMatch("foo", rule_name="var"))),
|
|
("('foo'=var)+", OneOrMore(StrMatch("foo", rule_name="var"))),
|
|
("r'str'=var", RegExMatch("str", rule_name="var")),
|
|
("r'foo'?=var", Optional(RegExMatch("foo"), rule_name="var")),
|
|
("(r'foo'?)=var", Optional(RegExMatch("foo"), rule_name="var")),
|
|
("r'foo'*=var", ZeroOrMore(RegExMatch("foo"), rule_name="var")),
|
|
("(r'foo'*)=var", ZeroOrMore(RegExMatch("foo"), rule_name="var")),
|
|
("r'foo'+=var", OneOrMore(RegExMatch("foo"), rule_name="var")),
|
|
("(r'foo'+)=var", OneOrMore(RegExMatch("foo"), rule_name="var")),
|
|
("r'foo'=var?", Optional(RegExMatch("foo", rule_name="var"))),
|
|
("(r'foo'=var)?", Optional(RegExMatch("foo", rule_name="var"))),
|
|
("r'foo'=var*", ZeroOrMore(RegExMatch("foo", rule_name="var"))),
|
|
("(r'foo'=var)*", ZeroOrMore(RegExMatch("foo", rule_name="var"))),
|
|
("r'foo'=var+", OneOrMore(RegExMatch("foo", rule_name="var"))),
|
|
("(r'foo'=var)+", OneOrMore(RegExMatch("foo", rule_name="var"))),
|
|
("(1 | 2 | 3)=var", OrderedChoice(StrMatch("1"), StrMatch("2"), StrMatch("3"), rule_name="var")),
|
|
("(1 2)=var", Sequence(StrMatch("1"), StrMatch("2"), rule_name="var")),
|
|
("(1 2)+=var", OneOrMore(Sequence(StrMatch("1"), StrMatch("2")), rule_name="var")),
|
|
("(1 2)=var+", OneOrMore(Sequence(StrMatch("1"), StrMatch("2"), rule_name="var"))),
|
|
("(1=a 2=b)=c", Sequence(StrMatch("1", rule_name="a"), StrMatch("2", rule_name="b"), rule_name="c")),
|
|
("(1*=a)", ZeroOrMore(StrMatch("1"), rule_name="a")),
|
|
("'a'* 'b'+", Sequence(ZeroOrMore(StrMatch("a")), OneOrMore(StrMatch("b")))),
|
|
("('a'* 'b'+)", Sequence(ZeroOrMore(StrMatch("a")), OneOrMore(StrMatch("b")))),
|
|
("('a'*=x 'b'+=y)=z", Sequence(
|
|
ZeroOrMore(StrMatch("a"), rule_name="x"),
|
|
OneOrMore(StrMatch("b"), rule_name="y"), rule_name="z")),
|
|
("'--filter'",
|
|
Sequence(StrMatch("-", skip_whitespace=False), StrMatch("-", skip_whitespace=False), StrMatch("filter")))
|
|
])
|
|
def test_i_can_parse_simple_bnf_definition(context, expression, expected):
|
|
parser = BnfDefinitionParser(context, expression)
|
|
res = parser.parse()
|
|
|
|
assert res == expected
|
|
assert not parser.error_sink
|
|
assert parser.source == expression
|
|
|
|
|
|
@pytest.mark.parametrize("expression, expected", [
|
|
("foo", _cexp("c:foo#1001:")),
|
|
("foo*", ZeroOrMore(_cexp("c:foo#1001:"))),
|
|
("foo 'and' bar+", Sequence(_cexp("c:foo#1001:"), StrMatch("and"), OneOrMore(_cexp("c:bar#1002:")))),
|
|
("foo | bar?", OrderedChoice(_cexp("c:foo#1001:"), Optional(_cexp("c:bar#1002:")))),
|
|
("'str' = var", Sequence(StrMatch("str"), StrMatch("="), _cexp("c:var#1003:"))),
|
|
("'str''='var", Sequence(StrMatch("str"), StrMatch("="), _cexp("c:var#1003:"))),
|
|
("foo=f", _cexp("c:foo#1001:", "f")),
|
|
("foo=f 'constant'", Sequence(_cexp("c:foo#1001:", "f"), StrMatch("constant"))),
|
|
("def 'concept'", Sequence(_cexp("c:def#1004:"), StrMatch("concept"))),
|
|
("c:foo:", _cexp("c:foo#1001:")),
|
|
("c:#1001:", _cexp("c:foo#1001:")),
|
|
])
|
|
def test_i_can_parse_bnf_definition_with_concepts(context, expression, expected):
|
|
with NewOntology(context, "test_i_can_parse_bnf_definition_with_concept"):
|
|
get_concepts(context, "foo", "bar", "var", "def", use_sheerka=True)
|
|
|
|
parser = BnfDefinitionParser(context, expression)
|
|
res = parser.parse()
|
|
|
|
assert res == expected
|
|
assert not parser.error_sink
|
|
assert parser.source == expression
|
|
|
|
|
|
@pytest.mark.parametrize("expression, expected", [
|
|
("x", VariableExpression("x")),
|
|
("x bar", Sequence(VariableExpression("x"), _cexp("c:bar#1001:"))),
|
|
("bar x", Sequence(_cexp("c:bar#1001:"), VariableExpression("x"))),
|
|
("x 'and' bar", Sequence(VariableExpression("x"), StrMatch("and"), _cexp("c:bar#1001:"))),
|
|
("x | bar", OrderedChoice(VariableExpression("x"), _cexp("c:bar#1001:"))),
|
|
("x*", ZeroOrMore(VariableExpression("x"))),
|
|
("x+", OneOrMore(VariableExpression("x"))),
|
|
("'str' = x", Sequence(StrMatch("str"), StrMatch("="), VariableExpression("x"))),
|
|
("'str''='x", Sequence(StrMatch("str"), StrMatch("="), VariableExpression("x"))),
|
|
("foo=x", VariableExpression("x")),
|
|
])
|
|
def test_i_can_parse_bnf_definition_with_variables(context, expression, expected):
|
|
with NewOntology(context, "test_i_can_parse_bnf_definition_with_variables"):
|
|
get_concepts(context, "bar", use_sheerka=True)
|
|
|
|
parser = BnfDefinitionParser(context, expression)
|
|
res = parser.parse()
|
|
|
|
assert res == expected
|
|
assert not parser.error_sink
|
|
assert parser.source == expression
|
|
|
|
|
|
def test_i_can_parse_when_the_concept_is_still_under_creation(context):
|
|
# I want to parse something like
|
|
# def concept add from bnf add | mult
|
|
# 'add' is used while being under construction
|
|
# 'add' must not be detected as a variable
|
|
parser = BnfDefinitionParser(context, "add | 'mult'", concept_name="add")
|
|
res = parser.parse()
|
|
|
|
assert res == OrderedChoice(_cexp("c:add:"), StrMatch("mult"))
|
|
assert not parser.error_sink
|
|
|
|
|
|
@pytest.mark.parametrize("expression, error", [
|
|
("1 ", UnexpectedEof),
|
|
("1|", UnexpectedEof),
|
|
("(1|)", UnexpectedToken),
|
|
("1=", UnexpectedToken),
|
|
])
|
|
def test_i_can_detect_errors(context, expression, error):
|
|
parser = BnfDefinitionParser(context, expression)
|
|
res = parser.parse()
|
|
|
|
assert res is None
|
|
assert len(parser.error_sink) > 0
|
|
assert isinstance(parser.error_sink[0], error)
|