1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/* Copyright 2016-2017 Tobias Grosser
*
* Use of this software is governed by the MIT license
*
* Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
*/
#ifndef IS_TRUE
#define IS_TRUE(b) (b)
#endif
/* Test the pointer interface for interaction between isl C and C++ types.
*
* This tests:
* - construction from an isl C object
* - check that constructed objects are non-null
* - get a non-owned C pointer from an isl C++ object usable in __isl_keep
* methods
* - use copy to get an owned C pointer from an isl C++ object which is usable
* in __isl_take methods. Verify that the original C++ object retains a valid
* pointer.
* - use release to get an owned C pointer from an isl C++ object which is
* usable in __isl_take methods. Verify that the original C++ object gave up
* its pointer and now is null.
*/
void test_pointer(isl::ctx ctx)
{
isl_set *c_empty = isl_set_read_from_str(ctx.get(), "{ : false }");
isl::set empty = isl::manage(c_empty);
assert(IS_TRUE(empty.is_empty()));
assert(isl_set_is_empty(empty.get()));
assert(!empty.is_null());
isl_set_free(empty.copy());
assert(!empty.is_null());
isl_set_free(empty.release());
assert(empty.is_null());
}
/* Test that isl objects can be constructed.
*
* This tests:
* - construction of a null object
* - construction from a string
* - construction from an integer
* - static constructor without a parameter
* - conversion construction (implicit)
* - conversion construction (explicit)
*
* The tests to construct from integers and strings cover functionality that
* is also tested in the parameter type tests, but here we verify that
* multiple overloaded constructors are available and that overload resolution
* works as expected.
*
* Construction from an isl C pointer is tested in test_pointer.
*/
void test_constructors(isl::ctx ctx)
{
isl::val null;
assert(null.is_null());
isl::val zero_from_str = isl::val(ctx, "0");
assert(IS_TRUE(zero_from_str.is_zero()));
isl::val zero_int_con = isl::val(ctx, 0);
assert(IS_TRUE(zero_int_con.is_zero()));
isl::val zero_static_con = isl::val::zero(ctx);
assert(IS_TRUE(zero_static_con.is_zero()));
isl::basic_set bs(ctx, "{ [1] }");
isl::set result(ctx, "{ [1] }");
isl::set s = bs;
assert(IS_TRUE(s.is_equal(result)));
isl::set s2(bs);
assert(IS_TRUE(s.unite(s2).is_equal(result)));
}
/* Test integer function parameters.
*
* Verify that extreme values and zero work.
*/
void test_parameters_int(isl::ctx ctx)
{
isl::val long_max_str(ctx, std::to_string(LONG_MAX));
isl::val long_max_int(ctx, LONG_MAX);
assert(IS_TRUE(long_max_str.eq(long_max_int)));
isl::val long_min_str(ctx, std::to_string(LONG_MIN));
isl::val long_min_int(ctx, LONG_MIN);
assert(IS_TRUE(long_min_str.eq(long_min_int)));
isl::val long_zero_str = isl::val(ctx, std::to_string(0));
isl::val long_zero_int = isl::val(ctx, 0);
assert(IS_TRUE(long_zero_str.eq(long_zero_int)));
}
/* 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.
*/
void test_parameters_obj(isl::ctx ctx)
{
isl::set a(ctx, "{ [0] }");
isl::set b(ctx, "{ [1] }");
isl::set c(ctx, "{ [2] }");
isl::set expected(ctx, "{ [i] : 0 <= i <= 2 }");
isl::set tmp = a.unite(b);
isl::set res_lvalue_param = tmp.unite(c);
assert(IS_TRUE(res_lvalue_param.is_equal(expected)));
isl::set res_rvalue_param = a.unite(b).unite(c);
assert(IS_TRUE(res_rvalue_param.is_equal(expected)));
isl::basic_set a2(ctx, "{ [0] }");
assert(IS_TRUE(a.is_equal(a2)));
isl::val two(ctx, 2);
isl::val half(ctx, "1/2");
isl::val res_only_this_param = two.inv();
assert(IS_TRUE(res_only_this_param.eq(half)));
}
/* Test different kinds of parameters to be passed to functions.
*
* This includes integer and isl C++ object parameters.
*/
void test_parameters(isl::ctx ctx)
{
test_parameters_int(ctx);
test_parameters_obj(ctx);
}
/* Test that isl objects are returned correctly.
*
* This only tests that after combining two objects, the result is successfully
* returned.
*/
void test_return_obj(isl::ctx ctx)
{
isl::val one(ctx, "1");
isl::val two(ctx, "2");
isl::val three(ctx, "3");
isl::val res = one.add(two);
assert(IS_TRUE(res.eq(three)));
}
/* Test that integer values are returned correctly.
*/
void test_return_int(isl::ctx ctx)
{
isl::val one(ctx, "1");
isl::val neg_one(ctx, "-1");
isl::val zero(ctx, "0");
assert(one.sgn() > 0);
assert(neg_one.sgn() < 0);
assert(zero.sgn() == 0);
}
/* Test that strings are returned correctly.
* Do so by calling overloaded isl::ast_build::from_expr methods.
*/
void test_return_string(isl::ctx ctx)
{
isl::set context(ctx, "[n] -> { : }");
isl::ast_build build = isl::ast_build::from_context(context);
isl::pw_aff pw_aff(ctx, "[n] -> { [n] }");
isl::set set(ctx, "[n] -> { : n >= 0 }");
isl::ast_expr expr = build.expr_from(pw_aff);
const char *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());
}