def test_list_add(): """Check that adding two HyLists generates a HyList""" a = HyList([1, 2, 3]) b = HyList([3, 4, 5]) c = a + b assert c == [1, 2, 3, 3, 4, 5] assert c.__class__ == HyList
def test_list_add(): """Check that adding two HyLists generates a HyList""" a = HyList([1, 2, 3]) b = HyList([3, 4, 5]) c = a + b assert c == HyList([1, 2, 3, 3, 4, 5]) assert type(c) is HyList
def test_list_slice(): """Check that slicing a HyList produces a HyList""" a = HyList([1, 2, 3, 4]) sl1 = a[1:] sl5 = a[5:] assert type(sl1) == HyList assert sl1 == HyList([2, 3, 4]) assert type(sl5) == HyList assert sl5 == HyList([])
def test_compiler_yield_return(): """ Check that the compiler correctly generates return statements for a generator function. In Python versions prior to 3.3, the return statement in a generator can't take a value, so the final expression should not generate a return statement. From 3.3 onwards a return value should be generated. """ e = make_expression(HySymbol("fn"), HyList(), HyExpression([HySymbol("yield"), HyInteger(2)]), HyExpression([HySymbol("+"), HyInteger(1), HyInteger(1)])) ret = compiler.HyASTCompiler('test').compile_function_def(e) assert len(ret.stmts) == 1 stmt, = ret.stmts assert isinstance(stmt, ast.FunctionDef) body = stmt.body assert len(body) == 2 assert isinstance(body[0], ast.Expr) assert isinstance(body[0].value, ast.Yield) if PY3: # From 3.3+, the final statement becomes a return value assert isinstance(body[1], ast.Return) assert isinstance(body[1].value, ast.BinOp) else: # In earlier versions, the expression is not returned assert isinstance(body[1], ast.Expr) assert isinstance(body[1].value, ast.BinOp)
def test_compiler_yield_return(self): """ Check that the compiler correctly generates return statements for a generator function. In Python versions prior to 3.3, the return statement in a generator can't take a value, so the final expression should not generate a return statement. From 3.3 onwards a return value should be generated. """ ret = self.c.compile_function_def( self._make_expression( HySymbol("fn"), HyList(), HyExpression([HySymbol("yield"), HyInteger(2)]), HyExpression([HySymbol("+"), HyInteger(1), HyInteger(1)]))) self.assertEqual(len(ret.stmts), 1) stmt = ret.stmts[0] self.assertIsInstance(stmt, ast.FunctionDef) body = stmt.body self.assertEquals(len(body), 2) self.assertIsInstance(body[0], ast.Expr) self.assertIsInstance(body[0].value, ast.Yield) if PY33: # From 3.3+, the final statement becomes a return value self.assertIsInstance(body[1], ast.Return) self.assertIsInstance(body[1].value, ast.BinOp) else: # In earlier versions, the expression is not returned self.assertIsInstance(body[1], ast.Expr) self.assertIsInstance(body[1].value, ast.BinOp)
def test_cons_list(): """Check that cons of something and a list gets tokenized as a list""" entry = tokenize("(a . [])")[0] assert entry == HyList([HySymbol("a")]) assert type(entry) == HyList entry = tokenize("(a . ())")[0] assert entry == HyExpression([HySymbol("a")]) assert type(entry) == HyExpression entry = tokenize("(a b . {})")[0] assert entry == HyDict([HySymbol("a"), HySymbol("b")]) assert type(entry) == HyDict
def test_preprocessor_expression(): """ Test that macro expansion doesn't recurse""" obj = macroexpand( tokenize('(test (test "one" "two"))')[0], HyASTCompiler(__name__)) assert type(obj) == HyList assert type(obj[0]) == HyExpression assert obj[0] == HyExpression( [HySymbol("test"), HyString("one"), HyString("two")]) obj = HyList([HyString("one"), HyString("two")]) obj = tokenize('(shill ["one" "two"])')[0][1] assert obj == macroexpand(obj, HyASTCompiler(""))
def test_fn_compiler_empty_function(self): ret = self.c.compile_function_def( self._make_expression(HySymbol("fn"), HyList())) self.assertEqual(ret.imports, {}) self.assertEqual(len(ret.stmts), 1) stmt = ret.stmts[0] self.assertIsInstance(stmt, ast.FunctionDef) self.assertIsInstance(stmt.args, ast.arguments) self.assertEqual(stmt.args.vararg, None) self.assertEqual(stmt.args.kwarg, None) self.assertEqual(stmt.args.defaults, []) self.assertEqual(stmt.decorator_list, []) self.assertEqual(len(stmt.body), 1) self.assertIsInstance(stmt.body[0], ast.Pass) self.assertIsInstance(ret.expr, ast.Name)
def t_empty_list(p): return HyList([])
def t_list(p): return HyList(p[1])
def test_discard(): """Check that discarded terms are removed properly.""" # empty assert tokenize("") == [] # single assert tokenize("#_1") == [] # multiple assert tokenize("#_1 #_2") == [] assert tokenize("#_1 #_2 #_3") == [] # nested discard assert tokenize("#_ #_1 2") == [] assert tokenize("#_ #_ #_1 2 3") == [] # trailing assert tokenize("0") == [0] assert tokenize("0 #_1") == [0] assert tokenize("0 #_1 #_2") == [0] # leading assert tokenize("2") == [2] assert tokenize("#_1 2") == [2] assert tokenize("#_0 #_1 2") == [2] assert tokenize("#_ #_0 1 2") == [2] # both assert tokenize("#_1 2 #_3") == [2] assert tokenize("#_0 #_1 2 #_ #_3 4") == [2] # inside assert tokenize("0 #_1 2") == [0, 2] assert tokenize("0 #_1 #_2 3") == [0, 3] assert tokenize("0 #_ #_1 2 3") == [0, 3] # in HyList assert tokenize("[]") == [HyList([])] assert tokenize("[#_1]") == [HyList([])] assert tokenize("[#_1 #_2]") == [HyList([])] assert tokenize("[#_ #_1 2]") == [HyList([])] assert tokenize("[0]") == [HyList([HyInteger(0)])] assert tokenize("[0 #_1]") == [HyList([HyInteger(0)])] assert tokenize("[0 #_1 #_2]") == [HyList([HyInteger(0)])] assert tokenize("[2]") == [HyList([HyInteger(2)])] assert tokenize("[#_1 2]") == [HyList([HyInteger(2)])] assert tokenize("[#_0 #_1 2]") == [HyList([HyInteger(2)])] assert tokenize("[#_ #_0 1 2]") == [HyList([HyInteger(2)])] # in HySet assert tokenize("#{}") == [HySet()] assert tokenize("#{#_1}") == [HySet()] assert tokenize("#{0 #_1}") == [HySet([HyInteger(0)])] assert tokenize("#{#_1 0}") == [HySet([HyInteger(0)])] # in HyDict assert tokenize("{}") == [HyDict()] assert tokenize("{#_1}") == [HyDict()] assert tokenize("{#_0 1 2}") == [HyDict([HyInteger(1), HyInteger(2)])] assert tokenize("{1 #_0 2}") == [HyDict([HyInteger(1), HyInteger(2)])] assert tokenize("{1 2 #_0}") == [HyDict([HyInteger(1), HyInteger(2)])] # in HyExpression assert tokenize("()") == [HyExpression()] assert tokenize("(#_foo)") == [HyExpression()] assert tokenize("(#_foo bar)") == [HyExpression([HySymbol("bar")])] assert tokenize("(foo #_bar)") == [HyExpression([HySymbol("foo")])] assert tokenize("(foo :bar 1)") == [ HyExpression([HySymbol("foo"), HyKeyword(":bar"), HyInteger(1)]) ] assert tokenize("(foo #_:bar 1)") == [ HyExpression([HySymbol("foo"), HyInteger(1)]) ] assert tokenize("(foo :bar #_1)") == [ HyExpression([HySymbol("foo"), HyKeyword(":bar")]) ] # discard term with nesting assert tokenize("[1 2 #_[a b c [d e [f g] h]] 3 4]") == [ HyList([HyInteger(1), HyInteger(2), HyInteger(3), HyInteger(4)]) ] # discard with other prefix syntax assert tokenize("a #_'b c") == [HySymbol("a"), HySymbol("c")] assert tokenize("a '#_b c") == [ HySymbol("a"), HyExpression([HySymbol("quote"), HySymbol("c")]) ] assert tokenize("a '#_b #_c d") == [ HySymbol("a"), HyExpression([HySymbol("quote"), HySymbol("d")]) ] assert tokenize("a '#_ #_b c d") == [ HySymbol("a"), HyExpression([HySymbol("quote"), HySymbol("d")]) ]
def t_empty_list(state, p): return HyList([])
def test_wrap_tuple(): """ Test conversion of tuples.""" wrapped = wrap_value((HyInteger(0), )) assert type(wrapped) == HyList assert type(wrapped[0]) == HyInteger assert wrapped == HyList([HyInteger(0)])
def test_preprocessor_simple(): """ Test basic macro expansion """ obj = macroexpand( tokenize('(test "one" "two")')[0], HyASTCompiler(__name__)) assert obj == HyList(["one", "two"]) assert type(obj) == HyList
def tmac(ETname, *tree): """ Turn an expression into a list """ return HyList(tree)
def exec_fn(code, ns): tokens = HyList(tokenize(code)) hy_eval(tokens, ns, '__pineal__')
def test_replace_tuple(): """ Test replacing tuples.""" replaced = replace_hy_obj((0, ), HyInteger(13)) assert type(replaced) == HyList assert type(replaced[0]) == HyInteger assert replaced == HyList([HyInteger(0)])
def t_list(state, p): return HyList(p[1])