def test_list_add():
"""Check that adding two Lists generates a List"""
a = List([1, 2, 3])
b = List([3, 4, 5])
c = a + b
assert c == List([1, 2, 3, 3, 4, 5])
assert type(c) is List
def test_list_slice():
"""Check that slicing a List produces a List"""
a = List([1, 2, 3, 4])
sl1 = a[1:]
sl5 = a[5:]
assert type(sl1) == List
assert sl1 == List([2, 3, 4])
assert type(sl5) == List
assert sl5 == List([])
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(Symbol("fn"), List(),
Expression([Symbol("yield"),
Integer(2)]),
Expression([Symbol("+"),
Integer(1),
Integer(1)]))
ret = compiler.HyASTCompiler(types.ModuleType('test')).compile_atom(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)
assert isinstance(body[1], ast.Return)
assert isinstance(body[1].value, ast.BinOp)
def test_preprocessor_simple():
""" Test basic macro expansion """
obj = macroexpand(tokenize('(test "one" "two")')[0],
__name__,
HyASTCompiler(__name__))
assert obj == List(["one", "two"])
assert type(obj) == List
def test_preprocessor_expression():
"""Test that macro expansion doesn't recurse"""
obj = macroexpand(
tokenize('(test (test "one" "two"))')[0], __name__,
HyASTCompiler(__name__))
assert type(obj) == List
assert type(obj[0]) == Expression
assert obj[0] == Expression([Symbol("test"), String("one"), String("two")])
obj = List([String("one"), String("two")])
obj = tokenize('(shill ["one" "two"])')[0][1]
assert obj == macroexpand(obj, __name__, HyASTCompiler(__name__))
def add(self, target, new_name=None):
"""Add a new let-binding target, mapped to a new, unique name."""
if isinstance(target, (str, Symbol)):
if "." in target:
raise ValueError("binding target may not contain a dot")
name = mangle(target)
if new_name is None:
new_name = self.compiler.get_anon_var(f"_hy_let_{name}")
self.bindings[name] = new_name
if isinstance(target, Symbol):
return Symbol(new_name).replace(target)
return new_name
if new_name is not None:
raise ValueError("cannot specify name for compound targets")
if isinstance(target, List):
return List(map(self.add, target)).replace(target)
if (
isinstance(target, Expression)
and target
and target[0] in (Symbol(","), Symbol("unpack-iterable"))
):
return Expression([target[0], *map(self.add, target[1:])]).replace(target)
raise ValueError(f"invalid binding target: {type(target)}")
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") == [Integer(0)]
assert tokenize("0 #_1") == [Integer(0)]
assert tokenize("0 #_1 #_2") == [Integer(0)]
# leading
assert tokenize("2") == [Integer(2)]
assert tokenize("#_1 2") == [Integer(2)]
assert tokenize("#_0 #_1 2") == [Integer(2)]
assert tokenize("#_ #_0 1 2") == [Integer(2)]
# both
assert tokenize("#_1 2 #_3") == [Integer(2)]
assert tokenize("#_0 #_1 2 #_ #_3 4") == [Integer(2)]
# inside
assert tokenize("0 #_1 2") == [Integer(0), Integer(2)]
assert tokenize("0 #_1 #_2 3") == [Integer(0), Integer(3)]
assert tokenize("0 #_ #_1 2 3") == [Integer(0), Integer(3)]
# in List
assert tokenize("[]") == [List([])]
assert tokenize("[#_1]") == [List([])]
assert tokenize("[#_1 #_2]") == [List([])]
assert tokenize("[#_ #_1 2]") == [List([])]
assert tokenize("[0]") == [List([Integer(0)])]
assert tokenize("[0 #_1]") == [List([Integer(0)])]
assert tokenize("[0 #_1 #_2]") == [List([Integer(0)])]
assert tokenize("[2]") == [List([Integer(2)])]
assert tokenize("[#_1 2]") == [List([Integer(2)])]
assert tokenize("[#_0 #_1 2]") == [List([Integer(2)])]
assert tokenize("[#_ #_0 1 2]") == [List([Integer(2)])]
# in Set
assert tokenize("#{}") == [Set()]
assert tokenize("#{#_1}") == [Set()]
assert tokenize("#{0 #_1}") == [Set([Integer(0)])]
assert tokenize("#{#_1 0}") == [Set([Integer(0)])]
# in Dict
assert tokenize("{}") == [Dict()]
assert tokenize("{#_1}") == [Dict()]
assert tokenize("{#_0 1 2}") == [Dict([Integer(1), Integer(2)])]
assert tokenize("{1 #_0 2}") == [Dict([Integer(1), Integer(2)])]
assert tokenize("{1 2 #_0}") == [Dict([Integer(1), Integer(2)])]
# in Expression
assert tokenize("()") == [Expression()]
assert tokenize("(#_foo)") == [Expression()]
assert tokenize("(#_foo bar)") == [Expression([Symbol("bar")])]
assert tokenize("(foo #_bar)") == [Expression([Symbol("foo")])]
assert tokenize("(foo :bar 1)") == [
Expression([Symbol("foo"), Keyword("bar"),
Integer(1)])
]
assert tokenize("(foo #_:bar 1)") == [
Expression([Symbol("foo"), Integer(1)])
]
assert tokenize("(foo :bar #_1)") == [
Expression([Symbol("foo"), Keyword("bar")])
]
# discard term with nesting
assert tokenize("[1 2 #_[a b c [d e [f g] h]] 3 4]") == [
List([Integer(1), Integer(2),
Integer(3), Integer(4)])
]
# discard with other prefix syntax
assert tokenize("a #_'b c") == [Symbol("a"), Symbol("c")]
assert tokenize("a '#_b c") == [
Symbol("a"), Expression([Symbol("quote"), Symbol("c")])
]
assert tokenize("a '#_b #_c d") == [
Symbol("a"), Expression([Symbol("quote"), Symbol("d")])
]
assert tokenize("a '#_ #_b c d") == [
Symbol("a"), Expression([Symbol("quote"), Symbol("d")])
]
def t_empty_list(state, p):
return List([])
def t_list(state, p):
return List(p[1])
def test_replace_tuple():
""" Test replacing tuples."""
replaced = replace_hy_obj((0, ), Integer(13))
assert type(replaced) == List
assert type(replaced[0]) == Integer
assert replaced == List([Integer(0)])
def test_wrap_tuple():
""" Test conversion of tuples."""
wrapped = as_model((Integer(0),))
assert type(wrapped) == List
assert type(wrapped[0]) == Integer
assert wrapped == List([Integer(0)])
def tmac(ETname, *tree):
"""Turn an expression into a list"""
return List(tree)
def test_wrap_tuple():
wrapped = as_model((Integer(0), ))
assert type(wrapped) == List
assert type(wrapped[0]) == Integer
assert wrapped == List([Integer(0)])
