def test_if_elif():
ast = ctrl([
_if(_is(v("a"), c(8)), blk([asg(v("b"), c(3))])),
_if(_is(v("a"), c(4)), blk([asg(v("b"), c(2))]))
], blk())
parser = Parser(Tokenizer("if a is 8 { b = 3 } elif a is 4 { b = 2 }"))
assert parser.statement() == ast
def test_func_str():
ast = _def(v("t"), sig([]), blk([asg(v("a"), c(1)), ret(v("a"))]))
assert str(ast) == "func t() {\n" + TAB + "a = 1\n" + TAB + "return a\n}"
def test_tailing_new_line():
ast = add(v("a"), v("b"))
parser = Parser(Tokenizer("a+b\n"))
assert parser.expression() == ast
assert parser.cur_token == EOF
def test_empty_if_with_new_line():
ast = ctrl([_if(_is(v("a"), c(8)), blk())], blk())
parser = Parser(Tokenizer("if a is 8 { \n }"))
assert parser.statement() == ast
def test_simple():
ast = _def(v("t"), sig([]), blk([asg(v("a"), c(1))]))
parser = Parser(Tokenizer("func t() {a = 1}"))
assert parser.statement() == ast
def test_call():
ast = asg(v("a"), call(v("t"), [v("b"), v("c")]))
parser = Parser(Tokenizer("a = t(b, c)"))
assert parser.statement() == ast
def test_simple_return_var():
ast = _def(v("t"), sig([]), blk([asg(v("a"), c(1)), ret(v("a"))]))
parser = Parser(Tokenizer("func t() {a = 1\nreturn a}"))
assert parser.statement() == ast
def test_if():
ast = ctrl(
[_if(_is(getitem(v("a"), c(0)), c(8)), blk([asg(v("b"), c(3))]))],
blk())
parser = Parser(Tokenizer("if a[0] is 8 { b = 3 }"))
assert parser.statement() == ast
def test_const_bin_var():
ast = add(c(1), v("b"))
parser = Parser(Tokenizer("1+b"))
assert parser.expression() == ast
def test_var_bin_var():
ast = add(v("a"), v("b"))
parser = Parser(Tokenizer("a+b"))
assert parser.expression() == ast
def test_unary_var():
ast = _not(v("b"))
parser = Parser(Tokenizer("not b"))
assert parser.expression() == ast
import pytest
from littlepython.parser import Parser
from littlepython.tokenizer import Tokenizer
from tests import EOF, v, c, add, _not, div, _and, sub, _or, gt, lt, mod, ge, le, mult, _is_not, _is
@pytest.mark.parametrize("op, op_str", [
(add, "+"),
(sub, "-"),
(_not, "not"),
])
@pytest.mark.parametrize("operand, operand_str", [
(c(1), "1"),
(v("a"), "a"),
])
def test_uniary_ops(op, operand, op_str, operand_str):
ast = op(operand)
s = op_str + " " + operand_str
parser = Parser(Tokenizer(s))
assert parser.expression() == ast
@pytest.mark.parametrize("op, op_str", [
(div, "/"),
(mod, "%"),
(mult, "*"),
(add, "+"),
(sub, "-"),
(_is, "is"),
(_is_not, "is not"),
def test_simple():
ast = _for(asg(v("i"), c(0)), lt(v("i"), c(10)),
asg(v("i"), add(v("i"), c(1))), blk([asg(v("a"), c(1))]))
parser = Parser(Tokenizer("for i = 0; i < 10; i = i + 1 {a = 1}"))
assert parser.statement() == ast
def test_array():
ast = _for(asg(v("i"), c(0)), lt(v("i"), c(10)),
asg(v("i"), add(v("i"), c(1))),
blk([asg(v("a"), getitem(v("b"), v("i")))]))
parser = Parser(Tokenizer("for i = 0; i < 10; i = i + 1 {a = b[i]}"))
assert parser.statement() == ast
def test_func_call():
ast = asg(v("a"), call(v("t"), [add(v("b"), c(2)), add(c(1), v("c"))]))
assert "a = t(b + 2, 1 + c)" == str(ast)
def test_multiple_same_priority_bins_2():
ast1 = add(c(1), add(v("b"), add(c(4), v("a"))))
ast2 = add(add(add(c(1), v("b")), c(4)), v("a"))
parser = Parser(Tokenizer("1+b+4+a"))
expr = parser.expression()
assert expr == ast1 or expr == ast2
import pytest
from littlepython.ast import Array
from littlepython.parser import Parser
from littlepython.tokenizer import Tokenizer
from tests import getitem, v, c, blk, asg, _is, _if, ctrl, setitem, add
@pytest.mark.parametrize("var, var_str", [
(v("a"), "a"),
(getitem(v("a"), c(1)), "a[1]"),
])
@pytest.mark.parametrize("expr, expr_str", [
(c(0), "0"),
(v("b"), "b"),
(add(v("b"), c(1)), "b+1"),
])
def test_getitem(var, expr, var_str, expr_str):
ast = getitem(var, expr)
parser = Parser(Tokenizer(var_str + "[" + expr_str + "]"))
assert parser.variable() == ast
@pytest.mark.parametrize("var, var_str", [
(v("a"), "a"),
(getitem(v("a"), c(1)), "a[1]"),
])
@pytest.mark.parametrize("expr, expr_str", [
(c(0), "0"),
(add(v("b"), c(1)), "b+1"),
(v("b"), "b"),
def test_multiple_same_priority_bins_4():
ast1 = sub(c(1), add(v("b"), sub(c(4), v("a"))))
ast2 = sub(add(sub(c(1), v("b")), c(4)), v("a"))
parser = Parser(Tokenizer("1-b+4-a"))
expr = parser.expression()
assert expr == ast1 or expr == ast2
def test_simple_return():
ast = _def(v("t"), sig([]), blk([ret(c(1))]))
parser = Parser(Tokenizer("func t() {return 1}"))
assert parser.statement() == ast
def test_differing_priority_bins_1():
ast = add(c(1), div(v("b"), c(4)))
parser = Parser(Tokenizer("1+b/4"))
assert parser.expression() == ast
def test_with_params():
ast = _def(v("t"), sig([v("b"), v("c")]), blk([asg(v("a"), c(1))]))
parser = Parser(Tokenizer("func t(b, c) {a = 1}"))
assert parser.statement() == ast
def test_differing_priority_bins_2():
ast = add(div(c(1), v("b")), c(4))
parser = Parser(Tokenizer("1/b+4"))
assert parser.expression() == ast
def test_call_with_add():
ast = asg(v("a"), call(v("t"), [add(v("b"), c(2)), add(c(1), v("c"))]))
parser = Parser(Tokenizer("a = t(b+2, 1+c)"))
assert parser.statement() == ast
def test_parens():
ast = div(add(c(1), v("b")), c(4))
parser = Parser(Tokenizer("(1+b)/4"))
assert parser.expression() == ast
def test_var():
ast = v("a")
parser = Parser(Tokenizer("a"))
assert parser.statement() == ast
def test_if_with_new_lines():
ast = ctrl([_if(_is(v("a"), c(8)), blk([asg(v("b"), c(3))]))], blk())
parser = Parser(Tokenizer("if a is 8 {\nb = 3\n}"))
assert parser.statement() == ast
