def test_subroutine_call(args):
tokens = gen_tokens(f'Foo.foo({",".join(args)})')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.subroutine_call)
assert find_node(tree, 'identifier', 'Foo')
assert find_node(tree, 'identifier', 'foo')
def test_start():
tokens = gen_tokens('''
class Point {
field int _x;
field int _y;
constructor Point new(int x, int y) {
let _x = x + 1;
let _y = y + 1;
}
method void dispose() {
do Memory.deAlloc();
}
method int getX() { return _x; }
method int getY() { return _y; }
method boolean lt(Point other) {
return ((_x < other.getX())
| ((_x = other.getX()) & (_y < other.getY())));
}
}
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens)
assert tree.name == 'start'
def test_var_dec(varlist):
tokens = gen_tokens(f'var int {",".join(varlist)};')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.var_dec)
for var in varlist:
assert find_node(tree, 'identifier', var)
def test_subroutine_dec(scope):
tokens = gen_tokens(f'{scope} int name() {{ return; }}')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.subroutine_decs)
assert find_node(tree, 'keyword', scope)
assert find_node(tree, 'identifier', 'name')
def test_var_names(varlist):
tokens = gen_tokens(','.join(varlist))
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.var_names)
for var in varlist:
assert find_node(tree, 'identifier', var)
def test_expression():
tokens = gen_tokens('x < y')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.expression)
assert find_node(tree, 'identifier', 'x')
assert find_node(tree, 'symbol', '<')
assert find_node(tree, 'identifier', 'y')
def test_expression_list():
tokens = gen_tokens('a+b, c')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.expression_list)
assert find_node(tree, 'identifier', 'a')
assert find_node(tree, 'identifier', 'b')
assert find_node(tree, 'identifier', 'c')
def test_do_statements():
tokens = gen_tokens('do foo.Foo();')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.do_statement)
assert find_node(tree, 'keyword', 'do')
assert find_node(tree, 'identifier', 'foo')
assert find_node(tree, 'identifier', 'Foo')
def test_let_statements():
tokens = gen_tokens('let x = 0;')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.let_statement)
assert find_node(tree, 'keyword', 'let')
assert find_node(tree, 'identifier', 'x')
assert find_node(tree, 'int_const', 0)
def test_class_var_dec(scope):
tokens = gen_tokens(f'{scope} int x;')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.class_var_dec)
assert find_node(tree, 'keyword', scope)
assert find_node(tree, 'keyword', 'int')
assert find_node(tree, 'identifier', 'x')
def test_type_name(type_name):
tokens = gen_tokens(type_name)
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.type_name)
if type_name in jack_analyzer.type_names:
assert find_node(tree, 'keyword', type_name)
else:
assert find_node(tree, 'identifier', type_name)
def test_parameter_list():
tokens = gen_tokens(f'int x, boolean y')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.parameter_list)
assert find_node(tree, 'keyword', 'int')
assert find_node(tree, 'identifier', 'x')
assert find_node(tree, 'keyword', 'boolean')
assert find_node(tree, 'identifier', 'y')
def test_var_decs():
tokens = gen_tokens('''
var int x;
var boolean f;
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.var_decs)
assert find_node(tree, 'identifier', 'x')
assert find_node(tree, 'identifier', 'f')
def test_subroutine_decs():
tokens = gen_tokens('''
constructor Foo new() { return Foo; }
method void fn() { return; }
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.subroutine_decs)
assert find_node(tree, 'identifier', 'new')
assert find_node(tree, 'identifier', 'fn')
def test_class_var_decs():
tokens = gen_tokens('''
static int static_var;
field int field_var;
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.class_var_decs)
assert find_node(tree, 'identifier', 'static_var')
assert find_node(tree, 'identifier', 'field_var')
def test_statements():
tokens = gen_tokens('''
let x = 0;
do Foo.foo();
return;
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.statements)
assert find_node(tree, 'keyword', 'let')
assert find_node(tree, 'keyword', 'do')
assert find_node(tree, 'keyword', 'return')
def test_subroutine_body():
tokens = gen_tokens('''
{
var int x, y, z;
let z = x + y;
return z;
}
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.subroutine_body)
assert find_node(tree, 'keyword', 'var')
assert find_node(tree, 'keyword', 'let')
assert find_node(tree, 'keyword', 'return')
def test_class_dec():
tokens = gen_tokens('''
class Foo {
static int static_var;
field int field_var;
constructor Foo new() { return this; }
function void static_fn() { return; }
method void method_fn() { return; }
}
''')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.class_dec)
assert find_node(tree, 'identifier', 'static_var')
assert find_node(tree, 'identifier', 'field_var')
assert find_node(tree, 'identifier', 'new')
assert find_node(tree, 'identifier', 'static_fn')
assert find_node(tree, 'identifier', 'method_fn')
def test_constant(const):
tokens = gen_tokens(const)
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.constant)
assert find_node(tree, 'keyword', const)
def test_statement(stmt):
tokens = gen_tokens(stmt)
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.statement)
assert find_node(tree, 'keyword', stmt.split()[0])
def test_keyword():
tokens = gen_tokens('class')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.keyword)
assert find_node(tree, 'keyword', 'class')
def test_symbol():
tokens = gen_tokens('=')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.symbol)
assert find_node(tree, 'symbol', '=')
def test_return_statements(stmt):
tokens = gen_tokens(stmt)
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.return_statement)
assert find_node(tree, 'keyword', 'return')
def test_while_statements():
tokens = gen_tokens('while (x) { let x = x; }')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.while_statement)
assert find_node(tree, 'keyword', 'while')
def test_unary_op(op):
tokens = gen_tokens(op)
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.unary_op)
assert find_node(tree, 'symbol', op)
def test_string_cons():
tokens = gen_tokens('"qwerty"')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.string_const)
assert find_node(tree, 'string_const', '"qwerty"')
def test_int_const():
tokens = gen_tokens('1234')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.int_const)
assert find_node(tree, 'int_const', 1234)
def test_identifiers(name):
tokens = gen_tokens('foo')
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=getattr(a, name))
assert find_node(tree, 'identifier', 'foo')
def test_term(term):
tokens = gen_tokens(term)
a = jack_analyzer.Analyzer()
tree = a.start(tokens, entry_point=a.expression)
