lib/External/isl/isl_test_python.py - llvm-project/polly - Git at Google

 # Copyright 2016-2017 Tobias Grosser
 #
 # Use of this software is governed by the MIT license
 #
 # Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich

 import sys
 import isl

 # Test that isl objects can be constructed.
 #
 # This tests:
 #  - construction from a string
 #  - construction from an integer
 #  - static constructor without a parameter
 #  - conversion construction
 #  - construction of empty union set
 #
 #  The tests to construct from integers and strings cover functionality that
 #  is also tested in the parameter type tests, but here the presence of
 #  multiple overloaded constructors and overload resolution is tested.
 #
 def test_constructors():
     zero1 = isl.val("0")
     assert zero1.is_zero()

     zero2 = isl.val(0)
     assert zero2.is_zero()

     zero3 = isl.val.zero()
     assert zero3.is_zero()

     bs = isl.basic_set("{ [1] }")
     result = isl.set("{ [1] }")
     s = isl.set(bs)
     assert s.is_equal(result)

     us = isl.union_set("{ A[1]; B[2, 3] }")
     empty = isl.union_set.empty()
     assert us.is_equal(us.union(empty))


 # Test integer function parameters for a particular integer value.
 #
 def test_int(i):
     val_int = isl.val(i)
     val_str = isl.val(str(i))
     assert val_int.eq(val_str)


 # Test integer function parameters.
 #
 # Verify that extreme values and zero work.
 #
 def test_parameters_int():
     test_int(sys.maxsize)
     test_int(-sys.maxsize - 1)
     test_int(0)


 # Test isl objects parameters.
 #
 # Verify that isl objects can be passed as lvalue and rvalue parameters.
 # Also verify that isl object parameters are automatically type converted if
 # there is an inheritance relation. Finally, test function calls without
 # any additional parameters, apart from the isl object on which
 # the method is called.
 #
 def test_parameters_obj():
     a = isl.set("{ [0] }")
     b = isl.set("{ [1] }")
     c = isl.set("{ [2] }")
     expected = isl.set("{ [i] : 0 <= i <= 2 }")

     tmp = a.union(b)
     res_lvalue_param = tmp.union(c)
     assert res_lvalue_param.is_equal(expected)

     res_rvalue_param = a.union(b).union(c)
     assert res_rvalue_param.is_equal(expected)

     a2 = isl.basic_set("{ [0] }")
     assert a.is_equal(a2)

     two = isl.val(2)
     half = isl.val("1/2")
     res_only_this_param = two.inv()
     assert res_only_this_param.eq(half)


 # Test different kinds of parameters to be passed to functions.
 #
 # This includes integer and isl object parameters.
 #
 def test_parameters():
     test_parameters_int()
     test_parameters_obj()


 # Test that isl objects are returned correctly.
 #
 # This only tests that after combining two objects, the result is successfully
 # returned.
 #
 def test_return_obj():
     one = isl.val("1")
     two = isl.val("2")
     three = isl.val("3")

     res = one.add(two)

     assert res.eq(three)


 # Test that integer values are returned correctly.
 #
 def test_return_int():
     one = isl.val("1")
     neg_one = isl.val("-1")
     zero = isl.val("0")

     assert one.sgn() > 0
     assert neg_one.sgn() < 0
     assert zero.sgn() == 0


 # Test that isl_bool values are returned correctly.
 #
 # In particular, check the conversion to bool in case of true and false.
 #
 def test_return_bool():
     empty = isl.set("{ : false }")
     univ = isl.set("{ : }")

     b_true = empty.is_empty()
     b_false = univ.is_empty()

     assert b_true
     assert not b_false


 # Test that strings are returned correctly.
 # Do so by calling overloaded isl.ast_build.from_expr methods.
 #
 def test_return_string():
     context = isl.set("[n] -> { : }")
     build = isl.ast_build.from_context(context)
     pw_aff = isl.pw_aff("[n] -> { [n] }")
     set = isl.set("[n] -> { : n >= 0 }")

     expr = build.expr_from(pw_aff)
     expected_string = "n"
     assert expected_string == expr.to_C_str()

     expr = build.expr_from(set)
     expected_string = "n >= 0"
     assert expected_string == expr.to_C_str()


 # Test that return values are handled correctly.
 #
 # Test that isl objects, integers, boolean values, and strings are
 # returned correctly.
 #
 def test_return():
     test_return_obj()
     test_return_int()
     test_return_bool()
     test_return_string()


 # A class that is used to test isl.id.user.
 #
 class S:
     def __init__(self):
         self.value = 42


 # Test isl.id.user.
 #
 # In particular, check that the object attached to an identifier
 # can be retrieved again.
 #
 def test_user():
     id = isl.id("test", 5)
     id2 = isl.id("test2")
     id3 = isl.id("S", S())
     assert id.user() == 5, f"unexpected user object {id.user()}"
     assert id2.user() is None, f"unexpected user object {id2.user()}"
     s = id3.user()
     assert isinstance(s, S), f"unexpected user object {s}"
     assert s.value == 42, f"unexpected user object {s}"


 # Test that foreach functions are modeled correctly.
 #
 # Verify that closures are correctly called as callback of a 'foreach'
 # function and that variables captured by the closure work correctly. Also
 # check that the foreach function handles exceptions thrown from
 # the closure and that it propagates the exception.
 #
 def test_foreach():
     s = isl.set("{ [0]; [1]; [2] }")

     list = []

     def add(bs):
         list.append(bs)

     s.foreach_basic_set(add)

     assert len(list) == 3
     assert list[0].is_subset(s)
     assert list[1].is_subset(s)
     assert list[2].is_subset(s)
     assert not list[0].is_equal(list[1])
     assert not list[0].is_equal(list[2])
     assert not list[1].is_equal(list[2])

     def fail(bs):
         raise Exception("fail")

     caught = False
     try:
         s.foreach_basic_set(fail)
     except:
         caught = True
     assert caught


 # Test the functionality of "foreach_scc" functions.
 #
 # In particular, test it on a list of elements that can be completely sorted
 # but where two of the elements ("a" and "b") are incomparable.
 #
 def test_foreach_scc():
     list = isl.id_list(3)
     sorted = [isl.id_list(3)]
     data = {
         "a": isl.map("{ [0] -> [1] }"),
         "b": isl.map("{ [1] -> [0] }"),
         "c": isl.map("{ [i = 0:1] -> [i] }"),
     }
     for k, v in data.items():
         list = list.add(k)
     id = data["a"].space().domain().identity_multi_pw_aff_on_domain()

     def follows(a, b):
         map = data[b.name()].apply_domain(data[a.name()])
         return not map.lex_ge_at(id).is_empty()

     def add_single(scc):
         assert scc.size() == 1
         sorted[0] = sorted[0].concat(scc)

     list.foreach_scc(follows, add_single)
     assert sorted[0].size() == 3
     assert sorted[0].at(0).name() == "b"
     assert sorted[0].at(1).name() == "c"
     assert sorted[0].at(2).name() == "a"


 # Test the functionality of "every" functions.
 #
 # In particular, test the generic functionality and
 # test that exceptions are properly propagated.
 #
 def test_every():
     us = isl.union_set("{ A[i]; B[j] }")

     def is_empty(s):
         return s.is_empty()

     assert not us.every_set(is_empty)

     def is_non_empty(s):
         return not s.is_empty()

     assert us.every_set(is_non_empty)

     def in_A(s):
         return s.is_subset(isl.set("{ A[x] }"))

     assert not us.every_set(in_A)

     def not_in_A(s):
         return not s.is_subset(isl.set("{ A[x] }"))

     assert not us.every_set(not_in_A)

     def fail(s):
         raise Exception("fail")

     caught = False
     try:
         us.ever_set(fail)
     except:
         caught = True
     assert caught


 # Check basic construction of spaces.
 #
 def test_space():
     unit = isl.space.unit()
     set_space = unit.add_named_tuple("A", 3)
     map_space = set_space.add_named_tuple("B", 2)

     set = isl.set.universe(set_space)
     map = isl.map.universe(map_space)
     assert set.is_equal(isl.set("{ A[*,*,*] }"))
     assert map.is_equal(isl.map("{ A[*,*,*] -> B[*,*] }"))


 # Construct a simple schedule tree with an outer sequence node and
 # a single-dimensional band node in each branch, with one of them
 # marked coincident.
 #
 def construct_schedule_tree():
     A = isl.union_set("{ A[i] : 0 <= i < 10 }")
     B = isl.union_set("{ B[i] : 0 <= i < 20 }")

     node = isl.schedule_node.from_domain(A.union(B))
     node = node.child(0)

     filters = isl.union_set_list(A).add(B)
     node = node.insert_sequence(filters)

     f_A = isl.multi_union_pw_aff("[ { A[i] -> [i] } ]")
     node = node.child(0)
     node = node.child(0)
     node = node.insert_partial_schedule(f_A)
     node = node.member_set_coincident(0, True)
     node = node.ancestor(2)

     f_B = isl.multi_union_pw_aff("[ { B[i] -> [i] } ]")
     node = node.child(1)
     node = node.child(0)
     node = node.insert_partial_schedule(f_B)
     node = node.ancestor(2)

     return node.schedule()


 # Test basic schedule tree functionality.
 #
 # In particular, create a simple schedule tree and
 # - check that the root node is a domain node
 # - test map_descendant_bottom_up
 # - test foreach_descendant_top_down
 # - test every_descendant
 #
 def test_schedule_tree():
     schedule = construct_schedule_tree()
     root = schedule.root()

     assert type(root) == isl.schedule_node_domain

     count = [0]

     def inc_count(node):
         count[0] += 1
         return node

     root = root.map_descendant_bottom_up(inc_count)
     assert count[0] == 8

     def fail_map(node):
         raise Exception("fail")
         return node

     caught = False
     try:
         root.map_descendant_bottom_up(fail_map)
     except:
         caught = True
     assert caught

     count = [0]

     def inc_count(node):
         count[0] += 1
         return True

     root.foreach_descendant_top_down(inc_count)
     assert count[0] == 8

     count = [0]

     def inc_count(node):
         count[0] += 1
         return False

     root.foreach_descendant_top_down(inc_count)
     assert count[0] == 1

     def is_not_domain(node):
         return type(node) != isl.schedule_node_domain

     assert root.child(0).every_descendant(is_not_domain)
     assert not root.every_descendant(is_not_domain)

     def fail(node):
         raise Exception("fail")

     caught = False
     try:
         root.every_descendant(fail)
     except:
         caught = True
     assert caught

     domain = root.domain()
     filters = [isl.union_set("{}")]

     def collect_filters(node):
         if type(node) == isl.schedule_node_filter:
             filters[0] = filters[0].union(node.filter())
         return True

     root.every_descendant(collect_filters)
     assert domain.is_equal(filters[0])


 # Test marking band members for unrolling.
 # "schedule" is the schedule created by construct_schedule_tree.
 # It schedules two statements, with 10 and 20 instances, respectively.
 # Unrolling all band members therefore results in 30 at-domain calls
 # by the AST generator.
 #
 def test_ast_build_unroll(schedule):
     root = schedule.root()

     def mark_unroll(node):
         if type(node) == isl.schedule_node_band:
             node = node.member_set_ast_loop_unroll(0)
         return node

     root = root.map_descendant_bottom_up(mark_unroll)
     schedule = root.schedule()

     count_ast = [0]

     def inc_count_ast(node, build):
         count_ast[0] += 1
         return node

     build = isl.ast_build()
     build = build.set_at_each_domain(inc_count_ast)
     ast = build.node_from(schedule)
     assert count_ast[0] == 30


 # Test basic AST generation from a schedule tree.
 #
 # In particular, create a simple schedule tree and
 # - generate an AST from the schedule tree
 # - test at_each_domain
 # - test unrolling
 #
 def test_ast_build():
     schedule = construct_schedule_tree()

     count_ast = [0]

     def inc_count_ast(node, build):
         count_ast[0] += 1
         return node

     build = isl.ast_build()
     build_copy = build.set_at_each_domain(inc_count_ast)
     ast = build.node_from(schedule)
     assert count_ast[0] == 0
     count_ast[0] = 0
     ast = build_copy.node_from(schedule)
     assert count_ast[0] == 2
     build = build_copy
     count_ast[0] = 0
     ast = build.node_from(schedule)
     assert count_ast[0] == 2

     do_fail = True
     count_ast_fail = [0]

     def fail_inc_count_ast(node, build):
         count_ast_fail[0] += 1
         if do_fail:
             raise Exception("fail")
         return node

     build = isl.ast_build()
     build = build.set_at_each_domain(fail_inc_count_ast)
     caught = False
     try:
         ast = build.node_from(schedule)
     except:
         caught = True
     assert caught
     assert count_ast_fail[0] > 0
     build_copy = build
     build_copy = build_copy.set_at_each_domain(inc_count_ast)
     count_ast[0] = 0
     ast = build_copy.node_from(schedule)
     assert count_ast[0] == 2
     count_ast_fail[0] = 0
     do_fail = False
     ast = build.node_from(schedule)
     assert count_ast_fail[0] == 2

     test_ast_build_unroll(schedule)


 # Test basic AST expression generation from an affine expression.
 #
 def test_ast_build_expr():
     pa = isl.pw_aff("[n] -> { [n + 1] }")
     build = isl.ast_build.from_context(pa.domain())

     op = build.expr_from(pa)
     assert type(op) == isl.ast_expr_op_add
     assert op.n_arg() == 2


 # Test the isl Python interface
 #
 # This includes:
 #  - Object construction
 #  - Different parameter types
 #  - Different return types
 #  - isl.id.user
 #  - Foreach functions
 #  - Foreach SCC function
 #  - Every functions
 #  - Spaces
 #  - Schedule trees
 #  - AST generation
 #  - AST expression generation
 #
 test_constructors()
 test_parameters()
 test_return()
 test_user()
 test_foreach()
 test_foreach_scc()
 test_every()
 test_space()
 test_schedule_tree()
 test_ast_build()
 test_ast_build_expr()
	# Copyright 2016-2017 Tobias Grosser
	#
	# Use of this software is governed by the MIT license
	#
	# Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich

	import sys
	import isl

	# Test that isl objects can be constructed.
	#
	# This tests:
	# - construction from a string
	# - construction from an integer
	# - static constructor without a parameter
	# - conversion construction
	# - construction of empty union set
	#
	# The tests to construct from integers and strings cover functionality that
	# is also tested in the parameter type tests, but here the presence of
	# multiple overloaded constructors and overload resolution is tested.
	#
	def test_constructors():
	zero1 = isl.val("0")
	assert zero1.is_zero()

	zero2 = isl.val(0)
	assert zero2.is_zero()

	zero3 = isl.val.zero()
	assert zero3.is_zero()

	bs = isl.basic_set("{ [1] }")
	result = isl.set("{ [1] }")
	s = isl.set(bs)
	assert s.is_equal(result)

	us = isl.union_set("{ A[1]; B[2, 3] }")
	empty = isl.union_set.empty()
	assert us.is_equal(us.union(empty))


	# Test integer function parameters for a particular integer value.
	#
	def test_int(i):
	val_int = isl.val(i)
	val_str = isl.val(str(i))
	assert val_int.eq(val_str)


	# Test integer function parameters.
	#
	# Verify that extreme values and zero work.
	#
	def test_parameters_int():
	test_int(sys.maxsize)
	test_int(-sys.maxsize - 1)
	test_int(0)


	# Test isl objects parameters.
	#
	# Verify that isl objects can be passed as lvalue and rvalue parameters.
	# Also verify that isl object parameters are automatically type converted if
	# there is an inheritance relation. Finally, test function calls without
	# any additional parameters, apart from the isl object on which
	# the method is called.
	#
	def test_parameters_obj():
	a = isl.set("{ [0] }")
	b = isl.set("{ [1] }")
	c = isl.set("{ [2] }")
	expected = isl.set("{ [i] : 0 <= i <= 2 }")

	tmp = a.union(b)
	res_lvalue_param = tmp.union(c)
	assert res_lvalue_param.is_equal(expected)

	res_rvalue_param = a.union(b).union(c)
	assert res_rvalue_param.is_equal(expected)

	a2 = isl.basic_set("{ [0] }")
	assert a.is_equal(a2)

	two = isl.val(2)
	half = isl.val("1/2")
	res_only_this_param = two.inv()
	assert res_only_this_param.eq(half)


	# Test different kinds of parameters to be passed to functions.
	#
	# This includes integer and isl object parameters.
	#
	def test_parameters():
	test_parameters_int()
	test_parameters_obj()


	# Test that isl objects are returned correctly.
	#
	# This only tests that after combining two objects, the result is successfully
	# returned.
	#
	def test_return_obj():
	one = isl.val("1")
	two = isl.val("2")
	three = isl.val("3")

	res = one.add(two)

	assert res.eq(three)


	# Test that integer values are returned correctly.
	#
	def test_return_int():
	one = isl.val("1")
	neg_one = isl.val("-1")
	zero = isl.val("0")

	assert one.sgn() > 0
	assert neg_one.sgn() < 0
	assert zero.sgn() == 0


	# Test that isl_bool values are returned correctly.
	#
	# In particular, check the conversion to bool in case of true and false.
	#
	def test_return_bool():
	empty = isl.set("{ : false }")
	univ = isl.set("{ : }")

	b_true = empty.is_empty()
	b_false = univ.is_empty()

	assert b_true
	assert not b_false


	# Test that strings are returned correctly.
	# Do so by calling overloaded isl.ast_build.from_expr methods.
	#
	def test_return_string():
	context = isl.set("[n] -> { : }")
	build = isl.ast_build.from_context(context)
	pw_aff = isl.pw_aff("[n] -> { [n] }")
	set = isl.set("[n] -> { : n >= 0 }")

	expr = build.expr_from(pw_aff)
	expected_string = "n"
	assert expected_string == expr.to_C_str()

	expr = build.expr_from(set)
	expected_string = "n >= 0"
	assert expected_string == expr.to_C_str()


	# Test that return values are handled correctly.
	#
	# Test that isl objects, integers, boolean values, and strings are
	# returned correctly.
	#
	def test_return():
	test_return_obj()
	test_return_int()
	test_return_bool()
	test_return_string()


	# A class that is used to test isl.id.user.
	#
	class S:
	def __init__(self):
	self.value = 42


	# Test isl.id.user.
	#
	# In particular, check that the object attached to an identifier
	# can be retrieved again.
	#
	def test_user():
	id = isl.id("test", 5)
	id2 = isl.id("test2")
	id3 = isl.id("S", S())
	assert id.user() == 5, f"unexpected user object {id.user()}"
	assert id2.user() is None, f"unexpected user object {id2.user()}"
	s = id3.user()
	assert isinstance(s, S), f"unexpected user object {s}"
	assert s.value == 42, f"unexpected user object {s}"


	# Test that foreach functions are modeled correctly.
	#
	# Verify that closures are correctly called as callback of a 'foreach'
	# function and that variables captured by the closure work correctly. Also
	# check that the foreach function handles exceptions thrown from
	# the closure and that it propagates the exception.
	#
	def test_foreach():
	s = isl.set("{ [0]; [1]; [2] }")

	list = []

	def add(bs):
	list.append(bs)

	s.foreach_basic_set(add)

	assert len(list) == 3
	assert list[0].is_subset(s)
	assert list[1].is_subset(s)
	assert list[2].is_subset(s)
	assert not list[0].is_equal(list[1])
	assert not list[0].is_equal(list[2])
	assert not list[1].is_equal(list[2])

	def fail(bs):
	raise Exception("fail")

	caught = False
	try:
	s.foreach_basic_set(fail)
	except:
	caught = True
	assert caught


	# Test the functionality of "foreach_scc" functions.
	#
	# In particular, test it on a list of elements that can be completely sorted
	# but where two of the elements ("a" and "b") are incomparable.
	#
	def test_foreach_scc():
	list = isl.id_list(3)
	sorted = [isl.id_list(3)]
	data = {
	"a": isl.map("{ [0] -> [1] }"),
	"b": isl.map("{ [1] -> [0] }"),
	"c": isl.map("{ [i = 0:1] -> [i] }"),
	}
	for k, v in data.items():
	list = list.add(k)
	id = data["a"].space().domain().identity_multi_pw_aff_on_domain()

	def follows(a, b):
	map = data[b.name()].apply_domain(data[a.name()])
	return not map.lex_ge_at(id).is_empty()

	def add_single(scc):
	assert scc.size() == 1
	sorted[0] = sorted[0].concat(scc)

	list.foreach_scc(follows, add_single)
	assert sorted[0].size() == 3
	assert sorted[0].at(0).name() == "b"
	assert sorted[0].at(1).name() == "c"
	assert sorted[0].at(2).name() == "a"


	# Test the functionality of "every" functions.
	#
	# In particular, test the generic functionality and
	# test that exceptions are properly propagated.
	#
	def test_every():
	us = isl.union_set("{ A[i]; B[j] }")

	def is_empty(s):
	return s.is_empty()

	assert not us.every_set(is_empty)

	def is_non_empty(s):
	return not s.is_empty()

	assert us.every_set(is_non_empty)

	def in_A(s):
	return s.is_subset(isl.set("{ A[x] }"))

	assert not us.every_set(in_A)

	def not_in_A(s):
	return not s.is_subset(isl.set("{ A[x] }"))

	assert not us.every_set(not_in_A)

	def fail(s):
	raise Exception("fail")

	caught = False
	try:
	us.ever_set(fail)
	except:
	caught = True
	assert caught


	# Check basic construction of spaces.
	#
	def test_space():
	unit = isl.space.unit()
	set_space = unit.add_named_tuple("A", 3)
	map_space = set_space.add_named_tuple("B", 2)

	set = isl.set.universe(set_space)
	map = isl.map.universe(map_space)
	assert set.is_equal(isl.set("{ A[,,*] }"))
	assert map.is_equal(isl.map("{ A[,,] -> B[,*] }"))


	# Construct a simple schedule tree with an outer sequence node and
	# a single-dimensional band node in each branch, with one of them
	# marked coincident.
	#
	def construct_schedule_tree():
	A = isl.union_set("{ A[i] : 0 <= i < 10 }")
	B = isl.union_set("{ B[i] : 0 <= i < 20 }")

	node = isl.schedule_node.from_domain(A.union(B))
	node = node.child(0)

	filters = isl.union_set_list(A).add(B)
	node = node.insert_sequence(filters)

	f_A = isl.multi_union_pw_aff("[ { A[i] -> [i] } ]")
	node = node.child(0)
	node = node.child(0)
	node = node.insert_partial_schedule(f_A)
	node = node.member_set_coincident(0, True)
	node = node.ancestor(2)

	f_B = isl.multi_union_pw_aff("[ { B[i] -> [i] } ]")
	node = node.child(1)
	node = node.child(0)
	node = node.insert_partial_schedule(f_B)
	node = node.ancestor(2)

	return node.schedule()


	# Test basic schedule tree functionality.
	#
	# In particular, create a simple schedule tree and
	# - check that the root node is a domain node
	# - test map_descendant_bottom_up
	# - test foreach_descendant_top_down
	# - test every_descendant
	#
	def test_schedule_tree():
	schedule = construct_schedule_tree()
	root = schedule.root()

	assert type(root) == isl.schedule_node_domain

	count = [0]

	def inc_count(node):
	count[0] += 1
	return node

	root = root.map_descendant_bottom_up(inc_count)
	assert count[0] == 8

	def fail_map(node):
	raise Exception("fail")
	return node

	caught = False
	try:
	root.map_descendant_bottom_up(fail_map)
	except:
	caught = True
	assert caught

	count = [0]

	def inc_count(node):
	count[0] += 1
	return True

	root.foreach_descendant_top_down(inc_count)
	assert count[0] == 8

	count = [0]

	def inc_count(node):
	count[0] += 1
	return False

	root.foreach_descendant_top_down(inc_count)
	assert count[0] == 1

	def is_not_domain(node):
	return type(node) != isl.schedule_node_domain

	assert root.child(0).every_descendant(is_not_domain)
	assert not root.every_descendant(is_not_domain)

	def fail(node):
	raise Exception("fail")

	caught = False
	try:
	root.every_descendant(fail)
	except:
	caught = True
	assert caught

	domain = root.domain()
	filters = [isl.union_set("{}")]

	def collect_filters(node):
	if type(node) == isl.schedule_node_filter:
	filters[0] = filters[0].union(node.filter())
	return True

	root.every_descendant(collect_filters)
	assert domain.is_equal(filters[0])


	# Test marking band members for unrolling.
	# "schedule" is the schedule created by construct_schedule_tree.
	# It schedules two statements, with 10 and 20 instances, respectively.
	# Unrolling all band members therefore results in 30 at-domain calls
	# by the AST generator.
	#
	def test_ast_build_unroll(schedule):
	root = schedule.root()

	def mark_unroll(node):
	if type(node) == isl.schedule_node_band:
	node = node.member_set_ast_loop_unroll(0)
	return node

	root = root.map_descendant_bottom_up(mark_unroll)
	schedule = root.schedule()

	count_ast = [0]

	def inc_count_ast(node, build):
	count_ast[0] += 1
	return node

	build = isl.ast_build()
	build = build.set_at_each_domain(inc_count_ast)
	ast = build.node_from(schedule)
	assert count_ast[0] == 30


	# Test basic AST generation from a schedule tree.
	#
	# In particular, create a simple schedule tree and
	# - generate an AST from the schedule tree
	# - test at_each_domain
	# - test unrolling
	#
	def test_ast_build():
	schedule = construct_schedule_tree()

	count_ast = [0]

	def inc_count_ast(node, build):
	count_ast[0] += 1
	return node

	build = isl.ast_build()
	build_copy = build.set_at_each_domain(inc_count_ast)
	ast = build.node_from(schedule)
	assert count_ast[0] == 0
	count_ast[0] = 0
	ast = build_copy.node_from(schedule)
	assert count_ast[0] == 2
	build = build_copy
	count_ast[0] = 0
	ast = build.node_from(schedule)
	assert count_ast[0] == 2

	do_fail = True
	count_ast_fail = [0]

	def fail_inc_count_ast(node, build):
	count_ast_fail[0] += 1
	if do_fail:
	raise Exception("fail")
	return node

	build = isl.ast_build()
	build = build.set_at_each_domain(fail_inc_count_ast)
	caught = False
	try:
	ast = build.node_from(schedule)
	except:
	caught = True
	assert caught
	assert count_ast_fail[0] > 0
	build_copy = build
	build_copy = build_copy.set_at_each_domain(inc_count_ast)
	count_ast[0] = 0
	ast = build_copy.node_from(schedule)
	assert count_ast[0] == 2
	count_ast_fail[0] = 0
	do_fail = False
	ast = build.node_from(schedule)
	assert count_ast_fail[0] == 2

	test_ast_build_unroll(schedule)


	# Test basic AST expression generation from an affine expression.
	#
	def test_ast_build_expr():
	pa = isl.pw_aff("[n] -> { [n + 1] }")
	build = isl.ast_build.from_context(pa.domain())

	op = build.expr_from(pa)
	assert type(op) == isl.ast_expr_op_add
	assert op.n_arg() == 2


	# Test the isl Python interface
	#
	# This includes:
	# - Object construction
	# - Different parameter types
	# - Different return types
	# - isl.id.user
	# - Foreach functions
	# - Foreach SCC function
	# - Every functions
	# - Spaces
	# - Schedule trees
	# - AST generation
	# - AST expression generation
	#
	test_constructors()
	test_parameters()
	test_return()
	test_user()
	test_foreach()
	test_foreach_scc()
	test_every()
	test_space()
	test_schedule_tree()
	test_ast_build()
	test_ast_build_expr()