/// \brief TODOCUMENT void operator()() { constexpr std_classn_rate_stat to_test = get<0>( get<I>( properties_of_classn_rate_stat::numerator_and_denominator_of_stat ) ); BOOST_CHECK_NO_THROW( classn_rate_stat<to_test>() ); classn_rate_stat<to_test> stat; BOOST_CHECK_NO_THROW( stat.get_name() ); BOOST_CHECK_GT( stat.get_name().length(), 0 ); }
static void test_greater_than() { { floating_point_emulation::tfloat<T, S> f(43), g(42); BOOST_CHECK_GT(f, g); } { floating_point_emulation::tfloat<T, S> f(43), g(42); BOOST_CHECK_EQUAL(f > g, true); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(43), g(42.); BOOST_CHECK_EQUAL(f > g, true); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(43.), g(42); BOOST_CHECK_EQUAL(f > g, true); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(43.), g(42.); BOOST_CHECK_EQUAL(f > g, true); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(42), g(42); BOOST_CHECK_EQUAL(f > g, false); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(42), g(42.); BOOST_CHECK_EQUAL(f > g, false); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(42.), g(42); BOOST_CHECK_EQUAL(f > g, false); BOOST_CHECK_EQUAL(g > f, false); } { floating_point_emulation::tfloat<T, S> f(42.), g(42.); BOOST_CHECK_EQUAL(f > g, false); BOOST_CHECK_EQUAL(g > f, false); } }
BOOST_FIXTURE_TEST_CASE_TEMPLATE( operator_less_partial_test, F, Fixtures, F ) { // for (auto p : F::Plist) for (auto it = F::Plist.begin(); it != F::Plist.end(); ++it) { auto p = *it; for (unsigned k = 0; k<16; k++) BOOST_CHECK_EQUAL( p.less_partial(p, k), 0 ); } // for (auto p : F::Plist) // for (auto q : F::Plist) for (auto itp = F::Plist.begin(); itp != F::Plist.end(); ++itp) { auto p = *itp; for (auto itq = F::Plist.begin(); itq != F::Plist.end(); ++itq) { auto q = *itq; BOOST_CHECK_EQUAL( p.less_partial(q, 0), 0 ); } } BOOST_CHECK_EQUAL( F::zero.less_partial(F::P01, 1), 0 ); BOOST_CHECK_EQUAL( F::P01.less_partial(F::zero, 1), 0 ); BOOST_CHECK_LT( F::zero.less_partial(F::P01, 2), 0 ); BOOST_CHECK_GT( F::P01.less_partial(F::zero, 2), 0 ); BOOST_CHECK_LT( F::zero.less_partial(F::P10, 1), 0 ); BOOST_CHECK_LT( F::zero.less_partial(F::P10, 2), 0 ); BOOST_CHECK_GT( F::P10.less_partial(F::zero, 1), 0 ); BOOST_CHECK_GT( F::P10.less_partial(F::zero, 2), 0 ); BOOST_CHECK_EQUAL( F::PPa.less_partial(F::PPb, 1), 0 ); BOOST_CHECK_EQUAL( F::PPa.less_partial(F::PPb, 2), 0 ); BOOST_CHECK_EQUAL( F::PPa.less_partial(F::PPb, 3), 0 ); BOOST_CHECK_LT( F::PPa.less_partial(F::PPb, 4), 0 ); BOOST_CHECK_LT( F::PPa.less_partial(F::PPb, 5), 0 ); BOOST_CHECK_GT( F::PPb.less_partial(F::PPa, 4), 0 ); BOOST_CHECK_GT( F::PPb.less_partial(F::PPa, 5), 0 ); }
BOOST_FIXTURE_TEST_CASE( advertising_scheduled, advertising ) { BOOST_CHECK_GT( scheduling().size(), 0 ); }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_neighbor_upper_bound, Tp, quad_sets ) { typedef quadrance<typename Tp::container_type, int, quad_diff> metric_type; typedef typename metric_type::distance_type distance_type; typedef neighbor_iterator<typename Tp::container_type, metric_type> neighbor_iterator_type; // Prove that you can find lower bound with N nodes, down to 1 node { Tp fix(100, randomize(-20, 20)); metric_type metric; quad target; while (!fix.container.empty()) { randomize(-22, 22)(target, 0, 0); // Find min and max dist first distance_type min_dist; distance_type max_dist; typename Tp::container_type::iterator it = fix.container.begin(); min_dist = max_dist = metric.distance_to_key(fix.container.rank()(), *it, target); ++it; for (; it != fix.container.end(); ++it) { distance_type tmp = metric.distance_to_key(fix.container.rank()(), *it, target); if (tmp < min_dist) min_dist = tmp; if (tmp > max_dist) max_dist = tmp; } distance_type avg_dist = (min_dist + max_dist) / 2; // use this knowledge to test the upper bound neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, min_dist); BOOST_CHECK(i != neighbor_begin(fix.container, metric, target)); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LT(min_dist, distance(i)); } BOOST_CHECK_EQUAL(min_dist, distance(--i)); i = neighbor_upper_bound(fix.container, metric, target, max_dist); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, avg_dist); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_GT(distance(i), avg_dist); } if (i == neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LE(distance(--i), avg_dist); } fix.container.erase(i); } } // Prove that you can find the upper bound when node and target are same { Tp fix(100, same()); metric_type metric; quad target; same()(target, 0, 100); // All points and targets are the same. while (!fix.container.empty()) { neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, 1); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, 0); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); fix.container.erase(--i); } } // Prove that you can find the upper bound in an unbalanced tree { Tp fix(100, increase()); metric_type metric; quad target; while (!fix.container.empty()) { randomize(0, 100)(target, 0, 0); // Find min and max dist first distance_type min_dist; distance_type max_dist; typename Tp::container_type::iterator it = fix.container.begin(); min_dist = max_dist = metric.distance_to_key(fix.container.rank()(), *it, target); ++it; for (; it != fix.container.end(); ++it) { distance_type tmp = metric.distance_to_key(fix.container.rank()(), *it, target); if (tmp < min_dist) min_dist = tmp; if (tmp > max_dist) max_dist = tmp; } distance_type avg_dist = (min_dist + max_dist) / 2; // Use this knowledge to test the upper bound neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, min_dist); BOOST_CHECK(i != neighbor_begin(fix.container, metric, target)); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LT(min_dist, distance(i)); } BOOST_CHECK_EQUAL(min_dist, distance(--i)); i = neighbor_upper_bound(fix.container, metric, target, max_dist); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, avg_dist); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_GT(distance(i), avg_dist); } if (i == neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LE(distance(--i), avg_dist); } fix.container.erase(i); } } // Prove that you can find the upper bound in an unbalanced tree { Tp fix(100, decrease()); metric_type metric; quad target; while (!fix.container.empty()) { randomize(0, 100)(target, 0, 0); // Find min and max dist first distance_type min_dist; distance_type max_dist; typename Tp::container_type::iterator it = fix.container.begin(); min_dist = max_dist = metric.distance_to_key(fix.container.rank()(), *it, target); ++it; for (; it != fix.container.end(); ++it) { distance_type tmp = metric.distance_to_key(fix.container.rank()(), *it, target); if (tmp < min_dist) min_dist = tmp; if (tmp > max_dist) max_dist = tmp; } distance_type avg_dist = (min_dist + max_dist) / 2; // Use this knowledge to test the upper bound neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, min_dist); BOOST_CHECK(i != neighbor_begin(fix.container, metric, target)); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LT(min_dist, distance(i)); } BOOST_CHECK_EQUAL(min_dist, distance(--i)); i = neighbor_upper_bound(fix.container, metric, target, max_dist); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, avg_dist); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_GT(distance(i), avg_dist); } if (i == neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LE(distance(--i), avg_dist); } fix.container.erase(i); } } }