mirror of
https://review.haiku-os.org/buildtools
synced 2024-11-23 07:18:49 +01:00
313 lines
8.0 KiB
C++
313 lines
8.0 KiB
C++
/* Copyright 2016-2017 Tobias Grosser
|
|
*
|
|
* Use of this software is governed by the MIT license
|
|
*
|
|
* Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
|
|
*/
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <isl/options.h>
|
|
#include <isl/cpp-checked.h>
|
|
|
|
namespace isl { using namespace checked; }
|
|
|
|
static void assert_impl(bool condition, const char *file, int line,
|
|
const char *message)
|
|
{
|
|
if (condition)
|
|
return;
|
|
|
|
fprintf(stderr, "Assertion failed in %s:%d %s\n", file, line, message);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
static void assert_impl(isl::boolean condition, const char *file, int line,
|
|
const char *message)
|
|
{
|
|
assert_impl(bool(condition), file, line, message);
|
|
}
|
|
|
|
/* Return the value encapsulated by "s".
|
|
*/
|
|
static int size_val(isl::size s)
|
|
{
|
|
return s.is_error() ? -1 : unsigned(s);
|
|
}
|
|
|
|
#undef assert
|
|
#define assert(exp) assert_impl(exp, __FILE__, __LINE__, #exp)
|
|
#define IS_TRUE(b) (b).is_true()
|
|
#define SIZE_VAL(s) size_val(s)
|
|
|
|
#include "isl_test_cpp-generic.cc"
|
|
|
|
/* Test that isl_bool values are returned correctly.
|
|
*
|
|
* We check in detail the following parts of the isl::boolean class:
|
|
* - The is_true, is_false, and is_error functions return true in case they
|
|
* are called on a true, false, or error instance of isl::boolean,
|
|
* respectively
|
|
* - Explicit conversion to 'bool'
|
|
* - Implicit conversion to 'bool'
|
|
* - The complement operator
|
|
* - Explicit construction from 'true' and 'false'
|
|
* - Explicit construction form isl_bool
|
|
*/
|
|
void test_return_bool(isl::ctx ctx)
|
|
{
|
|
isl::set empty(ctx, "{ : false }");
|
|
isl::set univ(ctx, "{ : }");
|
|
isl::set null;
|
|
|
|
isl::boolean b_true = empty.is_empty();
|
|
isl::boolean b_false = univ.is_empty();
|
|
isl::boolean b_error = null.is_empty();
|
|
|
|
assert(b_true.is_true());
|
|
assert(!b_true.is_false());
|
|
assert(!b_true.is_error());
|
|
|
|
assert(!b_false.is_true());
|
|
assert(b_false.is_false());
|
|
assert(!b_false.is_error());
|
|
|
|
assert(!b_error.is_true());
|
|
assert(!b_error.is_false());
|
|
assert(b_error.is_error());
|
|
|
|
assert(bool(b_true) == true);
|
|
assert(bool(b_false) == false);
|
|
|
|
assert(b_true);
|
|
|
|
assert((!b_false).is_true());
|
|
assert((!b_true).is_false());
|
|
assert((!b_error).is_error());
|
|
|
|
assert(isl::boolean(true).is_true());
|
|
assert(!isl::boolean(true).is_false());
|
|
assert(!isl::boolean(true).is_error());
|
|
|
|
assert(isl::boolean(false).is_false());
|
|
assert(!isl::boolean(false).is_true());
|
|
assert(!isl::boolean(false).is_error());
|
|
|
|
assert(isl::manage(isl_bool_true).is_true());
|
|
assert(!isl::manage(isl_bool_true).is_false());
|
|
assert(!isl::manage(isl_bool_true).is_error());
|
|
|
|
assert(isl::manage(isl_bool_false).is_false());
|
|
assert(!isl::manage(isl_bool_false).is_true());
|
|
assert(!isl::manage(isl_bool_false).is_error());
|
|
|
|
assert(isl::manage(isl_bool_error).is_error());
|
|
assert(!isl::manage(isl_bool_error).is_true());
|
|
assert(!isl::manage(isl_bool_error).is_false());
|
|
}
|
|
|
|
/* Test that return values are handled correctly.
|
|
*
|
|
* Test that isl C++ objects, integers, boolean values, and strings are
|
|
* returned correctly.
|
|
*/
|
|
void test_return(isl::ctx ctx)
|
|
{
|
|
test_return_obj(ctx);
|
|
test_return_int(ctx);
|
|
test_return_bool(ctx);
|
|
test_return_string(ctx);
|
|
}
|
|
|
|
/* Test that foreach functions are modeled correctly.
|
|
*
|
|
* Verify that lambdas are correctly called as callback of a 'foreach'
|
|
* function and that variables captured by the lambda work correctly. Also
|
|
* check that the foreach function takes account of the return value of the
|
|
* lambda and aborts in case isl::stat::error is returned and then returns
|
|
* isl::stat::error itself.
|
|
*/
|
|
void test_foreach(isl::ctx ctx)
|
|
{
|
|
isl::set s(ctx, "{ [0]; [1]; [2] }");
|
|
|
|
std::vector<isl::basic_set> basic_sets;
|
|
|
|
auto add_to_vector = [&] (isl::basic_set bs) {
|
|
basic_sets.push_back(bs);
|
|
return isl::stat::ok();
|
|
};
|
|
|
|
isl::stat ret1 = s.foreach_basic_set(add_to_vector);
|
|
|
|
assert(ret1.is_ok());
|
|
assert(basic_sets.size() == 3);
|
|
assert(isl::set(basic_sets[0]).is_subset(s).is_true());
|
|
assert(isl::set(basic_sets[1]).is_subset(s).is_true());
|
|
assert(isl::set(basic_sets[2]).is_subset(s).is_true());
|
|
assert(!basic_sets[0].is_equal(basic_sets[1]).is_true());
|
|
|
|
auto fail = [&] (isl::basic_set bs) {
|
|
return isl::stat::error();
|
|
};
|
|
|
|
isl::stat ret2 = s.foreach_basic_set(fail);
|
|
|
|
assert(ret2.is_error());
|
|
}
|
|
|
|
/* Test the functionality of "every" functions.
|
|
*
|
|
* In particular, test the generic functionality and
|
|
* test that error conditions are properly propagated.
|
|
*/
|
|
static void test_every(isl::ctx ctx)
|
|
{
|
|
isl::union_set us(ctx, "{ A[i]; B[j] }");
|
|
|
|
test_every_generic(ctx);
|
|
|
|
auto fail = [] (isl::set s){
|
|
return isl::boolean::error();
|
|
};
|
|
assert(us.every_set(fail).is_error());
|
|
}
|
|
|
|
/* Test basic schedule tree functionality.
|
|
*
|
|
* In particular, create a simple schedule tree and
|
|
* - perform some generic tests
|
|
* - test map_descendant_bottom_up in the failing case
|
|
* - test foreach_descendant_top_down
|
|
* - test every_descendant
|
|
*/
|
|
static void test_schedule_tree(isl::ctx ctx)
|
|
{
|
|
auto root = test_schedule_tree_generic(ctx);
|
|
|
|
auto fail_map = [](isl::schedule_node node) {
|
|
return isl::schedule_node();
|
|
};
|
|
assert(root.map_descendant_bottom_up(fail_map).is_null());
|
|
|
|
int count = 0;
|
|
auto inc_count = [&count](isl::schedule_node node) {
|
|
count++;
|
|
return isl::boolean(true);
|
|
};
|
|
assert(root.foreach_descendant_top_down(inc_count).is_ok());
|
|
assert(count == 8);
|
|
|
|
count = 0;
|
|
auto inc_count_once = [&count](isl::schedule_node node) {
|
|
count++;
|
|
return isl::boolean(false);
|
|
};
|
|
assert(root.foreach_descendant_top_down(inc_count_once).is_ok());
|
|
assert(count == 1);
|
|
|
|
auto is_not_domain = [](isl::schedule_node node) {
|
|
return !node.isa<isl::schedule_node_domain>();
|
|
};
|
|
assert(root.child(0).every_descendant(is_not_domain).is_true());
|
|
assert(root.every_descendant(is_not_domain).is_false());
|
|
|
|
auto fail = [](isl::schedule_node node) {
|
|
return isl::boolean();
|
|
};
|
|
assert(root.every_descendant(fail).is_error());
|
|
|
|
auto domain = root.as<isl::schedule_node_domain>().domain();
|
|
auto filters = isl::union_set(ctx, "{}");
|
|
auto collect_filters = [&filters](isl::schedule_node node) {
|
|
if (node.isa<isl::schedule_node_filter>().is_true()) {
|
|
auto filter = node.as<isl::schedule_node_filter>();
|
|
filters = filters.unite(filter.filter());
|
|
}
|
|
return isl::boolean(true);
|
|
};
|
|
assert(!root.every_descendant(collect_filters).is_error());
|
|
assert(domain.is_equal(filters).is_true());
|
|
}
|
|
|
|
/* Test basic AST generation from a schedule tree.
|
|
*
|
|
* In particular, create a simple schedule tree and
|
|
* - perform some generic tests
|
|
* - test at_each_domain in the failing case
|
|
*/
|
|
static void test_ast_build(isl::ctx ctx)
|
|
{
|
|
auto schedule = test_ast_build_generic(ctx);
|
|
|
|
bool do_fail = true;
|
|
int count_ast_fail = 0;
|
|
auto fail_inc_count_ast =
|
|
[&count_ast_fail, &do_fail](isl::ast_node node,
|
|
isl::ast_build build) {
|
|
count_ast_fail++;
|
|
return do_fail ? isl::ast_node() : node;
|
|
};
|
|
auto build = isl::ast_build(ctx);
|
|
build = build.set_at_each_domain(fail_inc_count_ast);
|
|
auto ast = build.node_from(schedule);
|
|
assert(ast.is_null());
|
|
assert(count_ast_fail > 0);
|
|
auto build_copy = build;
|
|
int count_ast = 0;
|
|
auto inc_count_ast =
|
|
[&count_ast](isl::ast_node node, isl::ast_build build) {
|
|
count_ast++;
|
|
return node;
|
|
};
|
|
build_copy = build_copy.set_at_each_domain(inc_count_ast);
|
|
ast = build_copy.node_from(schedule);
|
|
assert(!ast.is_null());
|
|
assert(count_ast == 2);
|
|
count_ast_fail = 0;
|
|
do_fail = false;
|
|
ast = build.node_from(schedule);
|
|
assert(!ast.is_null());
|
|
assert(count_ast_fail == 2);
|
|
}
|
|
|
|
/* Test the isl checked C++ interface
|
|
*
|
|
* This includes:
|
|
* - The isl C <-> C++ pointer interface
|
|
* - Object construction
|
|
* - Different parameter types
|
|
* - Different return types
|
|
* - Foreach functions
|
|
* - Every functions
|
|
* - Spaces
|
|
* - Schedule trees
|
|
* - AST generation
|
|
* - AST expression generation
|
|
*/
|
|
int main()
|
|
{
|
|
isl_ctx *ctx = isl_ctx_alloc();
|
|
|
|
isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
|
|
|
|
test_pointer(ctx);
|
|
test_constructors(ctx);
|
|
test_parameters(ctx);
|
|
test_return(ctx);
|
|
test_foreach(ctx);
|
|
test_every(ctx);
|
|
test_space(ctx);
|
|
test_schedule_tree(ctx);
|
|
test_ast_build(ctx);
|
|
test_ast_build_expr(ctx);
|
|
|
|
isl_ctx_free(ctx);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|