def test_parser_try():
result = parse("try\n x=0")
try_block = result.block.try_block
assert try_block.try_statement.child(0) == Token("TRY", "try")
path = try_block.nested_block.block.rules.assignment.path
assert path.child(0) == Token("NAME", "x")
def test_objects_number_float():
"""
Ensures that a float is compiled correctly.
"""
tree = Tree('number', [Token('FLOAT', '1.2')])
assert Objects.number(tree) == 1.2
def test_objects_boolean():
tree = Tree('boolean', [Token('TRUE', 'true')])
assert Objects.boolean(tree) is True
def test_tree_extract_path_fragments():
subtree = Tree('fragment', [Token('NAME', 'two')])
tree = Tree('path', [Token('NAME', 'one'), subtree, subtree])
assert tree.extract_path() == 'one.two.two'
def test_tree_line():
tree = Tree('outer', [Tree('path', [Token('WORD', 'word', line=1)])])
assert tree.line() == '1'
def test_values_double_quoted_string():
result = parse('"red"\n')
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
expected = entity.values.string.child(0)
assert expected == Token('DOUBLE_QUOTED', '"red"')
"""
assert tree.is_unary() is False
def test_tree_find_operator(magic):
"""
Ensures find_operator can find the operator.
"""
tree = Tree('any', [])
tree.multiplication = magic()
result = tree.find_operator()
assert result == tree.multiplication.exponential.factor.child()
@mark.parametrize('tree', [
Tree('any', [0, Token('t', 't')]),
Tree('any', [Tree('multiplication', [0, Token('t', 't')])]),
Tree('any',
[Tree('multiplication', [Tree('exponential', [0, Token('t', 't')])])])
])
def test_tree_find_operator_depths(tree):
"""
Ensures find_operator can find operators at various depths
"""
assert tree.find_operator() == Token('t', 't')
def test_tree_expect(tree):
"""
Ensures expect throws an error
"""
def indent_token_dedent(level, ws_type=' '):
ws = ''.join(ws_type for _ in range(level))
return (Token('_NL', '\n' + ws), Token('_INDENT', ws),
Token('_DEDENT', ws), Token('_DOUBLE_DEDENT', ws))
@pytest.mark.parametrize(
"ast_tree,searched_tokens,expected",
[
(
Tree(
"document",
[
Tree(
"type_system_definition",
[
Tree(
"schema_definition",
[
Token("SCHEMA", "schema"),
Tree(
"query_operation_type_definition",
[
Token("QUERY", "query"),
Tree(
"named_type",
[
Token(
"IDENT",
"RootQueryCustomType",
)
],
),
],
),
# -*- coding: utf-8 -*-
from lark.lexer import Token
from storyscript.parser.Indenter import CustomIndenter
A = Token('A', 'A')
B = Token('B', 'B')
C = Token('C', 'C')
NL = Token('_NL', '\n')
WHILE = Token('_WHILE', 'while')
DEDENT = Token('_DEDENT', '')
def indent_token(level, ws_type=' '):
ws = ''.join(ws_type for _ in range(level))
return Token('_NL', '\n' + ws), Token('_INDENT', ws)
def indent_token_dedent(level, ws_type=' '):
ws = ''.join(ws_type for _ in range(level))
return (Token('_NL', '\n' + ws), Token('_INDENT', ws),
Token('_DEDENT', ws), Token('_DOUBLE_DEDENT', ws))
def test_indenter_one_level():
"""
while
a
b
"""
def indent_token(level, ws_type=' '):
ws = ''.join(ws_type for _ in range(level))
return Token('_NL', '\n' + ws), Token('_INDENT', ws)
def test_parser_number_float(number):
result = parse(number)
ar_exp = arith_exp(result.block.rules.absolute_expression)
entity = get_entity(ar_exp)
f = entity.values.number
assert f.child(0) == Token("FLOAT", number)
def test_parser_try_throw_error():
result = parse("try\n x=0\ncatch as error\n throw error")
nested_block = result.block.try_block.catch_block.nested_block
throw_statement = nested_block.block.rules.throw_statement
assert throw_statement.child(0) == "throw"
assert throw_statement.entity.path.child(0) == Token("NAME", "error")
def test_parser_try_catch():
result = parse("try\n x=0\ncatch as error\n x=1")
catch_block = result.block.try_block.catch_block
assert catch_block.catch_statement.child(1) == Token("NAME", "error")
path = catch_block.nested_block.block.rules.assignment.path
assert path.child(0) == Token("NAME", "x")
def test_values_false():
result = parse('false\n')
token = Token('FALSE', 'false')
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
assert entity.values.boolean.child(0) == token
def lex(self, data):
for obj in data:
yield Token('A', obj)
def test_values_null():
result = parse('null\n')
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
assert entity.values.void.child(0) == Token('NULL', 'null')
def process(self, stream):
yield from stream
yield Token('_EOI', '')
def test_faketree_path(patch, fake_tree):
patch.object(FakeTree, 'line')
FakeTree.line.return_value = 'fake.line'
result = fake_tree.path()
name = '__p-fake.line'
assert result == Tree('path', [Token('NAME', name, line=FakeTree.line())])
def test_values_list_empty():
result = parse("[]\n")
expected = Tree("list", [Token("OSB", "["), Token("CSB", "]")])
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
assert entity.values.list == expected
def test_tree_extract_path():
tree = Tree('path', [Token('NAME', 'one')])
assert tree.extract_path() == 'one'
def test_values_null():
result = parse("null\n")
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
assert entity.values.null.child(0) == Token("NULL_CONSTANT", "null")
def test_tree_find_operator_depths(tree):
"""
Ensures find_operator can find operators at various depths
"""
assert tree.find_operator() == Token('t', 't')
def symbolset(self, tree):
composite_type = Tree('composite_type', [Token('symbolset', 'symbolset')])
tree.data = 'composite'
tree.children.insert(0, composite_type)
return tree
def test_tree_column():
"""
Ensures Tree.column can find the column of a tree
"""
tree = Tree('outer', [Tree('path', [Token('WORD', 'word', column=1)])])
assert tree.column() == '1'
def test_values_list_empty():
result = parse('[]\n')
expected = Tree('list', [Token('OSB', '['), Token('CSB', ']')])
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
assert entity.values.list == expected
def test_objects_fillers_values(patch):
patch.object(Objects, 'path')
result = Objects.fillers_values(['one'])
Objects.path.assert_called_with(Tree('path', [Token('WORD', 'one')]))
assert result == [Objects.path()]
def test_values_true():
result = parse('true\n')
expression = result.block.rules.absolute_expression.expression
entity = get_entity(expression)
assert entity.values.boolean.child(0) == Token('TRUE', 'true')
def test_objects_boolean_false():
tree = Tree('boolean', [Token('FALSE', 'false')])
assert Objects.boolean(tree) is False
def test_parser_function_output():
result = parse("function test n:string returns int\n x = 1\n")
statement = result.block.function_block.function_statement
assert statement.function_output.types.base_type.child(0) == Token(
"INT_TYPE", "int"
)
