static void
test_construction() {
map<int, int> m1;
test_emptiness(m1);
test_copying(m1);
map<int, int> m2(il.begin(), il.end());
test_equality(m2, benchmark);
test_copying(m2);
map<int, int> m3(il);
test_equality(m3, benchmark);
test_copying(m3);
}
int main()
{
static_assert(noexcept(ex::new_delete_resource()), "Must be noexcept");
test_return();
test_equality();
test_allocate_deallocate();
}
int test_batch(gf2e *ff, rci_t m, rci_t n) {
int fail_ret = 0;
printf("elim: k: %2d, minpoly: 0x%05x m: %5d, n: %5d ",(int)ff->degree, (unsigned int)ff->minpoly, (int)m, (int)n);
if(m == n) {
m4rie_check( test_equality(ff, m, n) == 0); printf("."); fflush(0);
printf(" ");
} else {
m4rie_check( test_equality(ff, m, n) == 0); printf("."); fflush(0);
m4rie_check( test_equality(ff, n, m) == 0); printf("."); fflush(0);
}
if (fail_ret == 0)
printf(" passed\n");
else
printf(" FAILED\n");
return fail_ret;
}
static void
test_copying(const map<int, int>& m) {
map<int, int> m1 = m;
test_equality(m1, m);
map<int, int> m2 = std::move(m1);
test_equality(m2, m);
test_emptiness(m1);
m1 = m2;
test_equality(m1, m);
m2 = map<int, int>();
test_emptiness(m2);
m2 = std::move(m1);
test_equality(m2, m);
test_emptiness(m1);
}
inline void test_using_reverse(CombinedIterator first,
CombinedIterator beyond,
CombinedContainer& combined)
{
std::reverse(first, beyond);
std::reverse(combined.begin(), combined.end());
test_equality(first, beyond, combined);
#ifdef BOOST_GEOMETRY_TEST_DEBUG
print_container(std::cout, first, beyond, "reversed:") << std::endl;
#endif
std::reverse(first, beyond);
std::reverse(combined.begin(), combined.end());
test_equality(first, beyond, combined);
#ifdef BOOST_GEOMETRY_TEST_DEBUG
print_container(std::cout, first, beyond, "re-reversed:") << std::endl;
#endif
}
inline void test_using_remove_if(CombinedIterator first,
CombinedIterator beyond,
CombinedContainer& combined)
{
typedef typename std::iterator_traits
<
CombinedIterator
>::value_type value_type;
#ifdef BOOST_GEOMETRY_TEST_DEBUG
std::cout << std::endl;
std::cout << "odd elements removed:" << std::endl;
print_container(std::cout, first, beyond, "before:") << std::endl;
#endif
typename std::iterator_traits<CombinedIterator>::difference_type
num_even = std::count_if(first, beyond, is_even<value_type>());
CombinedIterator new_beyond =
std::remove_if(first, beyond, is_odd<value_type>());
std::size_t new_size = std::distance(first, new_beyond);
for (CombinedIterator it = first; it != new_beyond; ++it)
{
BOOST_CHECK( !is_odd<value_type>()(*it) );
}
BOOST_CHECK( new_size == static_cast<std::size_t>(num_even) );
#ifdef BOOST_GEOMETRY_TEST_DEBUG
print_container(std::cout, first, new_beyond, "after :") << std::endl;
#endif
combined.erase(std::remove_if(combined.begin(), combined.end(),
is_odd<value_type>()),
combined.end());
test_equality(first, new_beyond, combined);
}
// Used assert_true instead of assert to prevent compiler warnings
int main(void) {
uint32_t i;
bool ok;
init_rationals();
build_polys();
show_polys();
init_offset_manager(&mngr, NULL, notify_equality);
/*
* FIRST TESTS
*/
for (i=0; i<NPOLYS; i++) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
}
printf("\n*** Initial state ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_increase_decision_level(&mngr);
test_equality(var[3], var[4], 0, 123);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_backtrack(&mngr, 0);
printf("\n*** After backtracking to level 0 ***\n");
print_ptable(&mngr);
print_vtable(&mngr);
offset_manager_increase_decision_level(&mngr);
test_equality(var[3], -1, 1, 234);
test_equality(var[3], var[4], 0, 123);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_backtrack(&mngr, 0);
ok = offset_manager_propagate(&mngr);
printf("\n*** After backtracking to level 0 ***\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
/*
* SECOND TEST
*/
reset_offset_manager(&mngr);
printf("\n*** After reset ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
for (i=0; i<NPOLYS/2; i++) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
}
offset_manager_push(&mngr);
printf("\n*** After push ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
while (i < NPOLYS) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
i ++;
}
printf("\n*** After adding all polys ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
test_equality(var[5], var[3], 10, 111);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_pop(&mngr);
printf("\n*** After pop ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
test_equality(var[4], var[3], 10, 111);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
/*
* THIRD TEST
*/
reset_offset_manager(&mngr);
printf("\n*** After reset ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
for (i=0; i<6; i++) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
}
test_equality(var[5], var[3], 10, 111);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_push(&mngr);
printf("\n*** After push ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
while (i < NPOLYS) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
i ++;
}
printf("\n*** After adding all polys ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
test_equality(var[4], var[3], 10, 111);
test_equality(-1, var[3], 56, 122);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_pop(&mngr);
printf("\n*** After pop ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
delete_offset_manager(&mngr);
delete_polys();
cleanup_rationals();
return 0;
}
static void
test_insertion_erasure_and_searching() {
map<int, int> m;
const auto& cb = m;
std::map<int, int> sm;
const auto& csm = sm;
int i = 0;
for (const auto& x : il) {
if (i++ & 2)
m.insert(x);
else
m[x.first] = x.second;
sm.insert(x);
test_equality(m, sm);
test_copying(m);
test_searching(m .lower_bound(1), m .end(), sm .lower_bound(1), sm .end());
test_searching(m .lower_bound(2), m .end(), sm .lower_bound(2), sm .end());
test_searching(cb.lower_bound(1), cb.end(), csm.lower_bound(1), csm.end());
test_searching(cb.lower_bound(2), cb.end(), csm.lower_bound(2), csm.end());
test_searching(m .upper_bound(1), m .end(), sm .upper_bound(1), sm .end());
test_searching(m .upper_bound(2), m .end(), sm .upper_bound(2), sm .end());
test_searching(cb.upper_bound(1), cb.end(), csm.upper_bound(1), csm.end());
test_searching(cb.upper_bound(2), cb.end(), csm.upper_bound(2), csm.end());
test_searching(m .find(1), m .end(), sm .find(1), sm .end());
test_searching(m .find(2), m .end(), sm .find(2), sm .end());
test_searching(cb.find(1), cb.end(), csm.find(1), csm.end());
test_searching(cb.find(2), cb.end(), csm.find(2), csm.end());
}
for (const auto& x : il) {
auto im = m.find(x.first);
auto ism = sm.find(x.first);
assert((im == m.end()) == (ism == sm.end()));
if (im != m.end()) {
im = m.erase(im);
ism = sm.erase(ism);
}
assert((im == m.end()) == (ism == sm.end()));
assert(im == m.end() || *im == *ism);
}
m.insert(il.begin(), il.end());
sm = il;
test_equality(m, sm);
assert(m.erase(m.begin(), m.end()) == m.end());
test_emptiness(m);
m = il;
auto it = --m.end();
assert(m.erase(++m.begin(), it) == it);
sm = il;
sm.erase(++sm.begin(), --sm.end());
test_equality(m, sm);
}
