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" )