std::pair<int, std::string> test_simple_path(std::ostream& strm,int argc, const char *argv[]) { sparse_graph_t s10(10, graph_type_t::UNDIRECTED); // fig 17.23 p 67 s10.insert(simple_edge_t(0,1,1)); s10.insert(simple_edge_t(0,2,1)); s10.insert(simple_edge_t(0,6,1)); s10.insert(simple_edge_t(0,5,1)); s10.insert(simple_edge_t(1,2,1)); s10.insert(simple_edge_t(2,3,1)); s10.insert(simple_edge_t(3,4,1)); s10.insert(simple_edge_t(5,4,1)); s10.insert(simple_edge_t(2,4,1)); s10.insert(simple_edge_t(4,6,1)); s10.insert(simple_edge_t(7,8,1)); s10.insert(simple_edge_t(9,10,1)); s10.insert(simple_edge_t(9,11,1)); s10.insert(simple_edge_t(9,12,1)); s10.insert(simple_edge_t(11,12,1)); std::string dn = test_path("simple_path.dot"); s10.graphviz(dn); simple_edge_path_t sp(s10); simple_path_t p = sp(0, 5); ASSERT_CONDITION("there is a path from 0 to 5", p == true); ASSERT_CONDITION("there is a path no path from 0 to 9", sp(0,9) == false); return DONE; }
std::pair<int, std::string> test_adjacency_list_rm(std::ostream& strm,int argc, const char *argv[]) { std::set<adjacency_list_t::edge_tuple_t> exp_edges = { std::make_tuple(0,3,1), std::make_tuple(0,0,1), std::make_tuple(0,1,1), std::make_tuple(3,2,1) }; adjacency_list_t l1(10); l1(0,3,1); l1(0,0,1); l1(0,1,1); l1(1,4,1); l1(3,2,1); l1.rm(1,4); std::cerr << l1 << std::endl; ASSERT(l1.size() == 4); ASSERT(l1.max_size() == 10); ASSERT(l1(1,4) == 0); ASSERT(l1(0,3) == 1); std::set<adjacency_list_t::edge_tuple_t> edges; for (adjacency_list_t::iterator it = l1.begin(); it != l1.end(); it++) { edges.insert(*it); } ASSERT_CONDITION("rm : expected edges are iterated over", exp_edges == edges); return DONE; }
static bool param_compose_test(ot_op* op1, ot_op* op2, ot_op* expected, char** msg) { ot_op* actual = ot_compose(op1, op2); ot_free_op(op1); ot_free_op(op2); if (actual == NULL) { if (expected == NULL) { return true; } else { FAIL("Operations couldn't be composed.", msg); } } bool equal = ot_equal(expected, actual); char* expected_enc = ot_encode(expected); char* actual_enc = ot_encode(actual); ASSERT_CONDITION(equal, expected_enc, actual_enc, "Composed operation wasn't correct.", msg); ot_free_op(expected); ot_free_op(actual); free(expected_enc); free(actual_enc); return true; }
bool TestSuite::TestListDS() { printf("\n Running TestListDS...") ; upan::list<int> l ; l.push_back(100) ; l.push_back(200) ; l.push_back(300) ; l.insert(++l.begin(), 400) ; int arr[ ] = { 100, 400, 200, 300 } ; int i = 0 ; for(auto it : l) ASSERT_CONDITION(arr[ i++ ] == it) ; ASSERT_CONDITION(l.size() == 4) ; ASSERT_CONDITION(l.front() == 100) ; l.pop_front() ; ASSERT_CONDITION(l.size() == 3) ; ASSERT_CONDITION(l.front() == 400); ASSERT_CONDITION(l.back() == 300); return true ; }
std::pair<int, std::string> test_transitive_closure_dag(std::ostream& strm,int argc, const char *argv[]) { std::string fn = test_path("transitive_closure_dag.dot"); size_t size = 50; sparse_graph_t s10(size, graph_type_t::DIRECTED); s10.insert(simple_edge_t(0,1,1)); s10.insert(simple_edge_t(0,2,1)); s10.insert(simple_edge_t(0,3,1)); s10.insert(simple_edge_t(0,5,1)); s10.insert(simple_edge_t(0,6,1)); s10.insert(simple_edge_t(2,3,1)); s10.insert(simple_edge_t(3,4,1)); s10.insert(simple_edge_t(3,5,1)); s10.insert(simple_edge_t(4,9,1)); s10.insert(simple_edge_t(6,4,1)); s10.insert(simple_edge_t(6,9,1)); s10.insert(simple_edge_t(7,6,1)); s10.insert(simple_edge_t(8,7,1)); s10.insert(simple_edge_t(9,10,1)); s10.insert(simple_edge_t(9,11,1)); s10.insert(simple_edge_t(9,12,1)); s10.insert(simple_edge_t(11,12,1)); is_dag<simple_edge_t> is_dag(s10); ASSERT_CONDITION("graph is a DAG", is_dag()); s10.graphviz(fn); transitive_closure<sparse_graph_t, tc_dag<simple_edge_t>> tc(s10); std::string wts = test_path("transitive_closure_dag_results.dot"); (*tc).graphviz(wts); ASSERT(tc(simple_edge_t(0,1,1))); ASSERT(tc(simple_edge_t(0,12,1))) ASSERT(tc(simple_edge_t(0,11,1))); ASSERT(tc(simple_edge_t(8,12,1))) ASSERT(tc(simple_edge_t(0,10,1))); ASSERT(tc(simple_edge_t(3,4,1))) ASSERT(!tc(simple_edge_t(1,4,1))); ASSERT(!tc(simple_edge_t(4,1,1))) ASSERT(tc(simple_edge_t(0,2,1))); ASSERT(!tc(simple_edge_t(2,0,1))) ASSERT(tc(simple_edge_t(2,4,1))); return DONE; }
bool TestSuite::TestAtomicSwap() { printf("\n Running TestAtomicSwap...") ; Mutex m ; ASSERT_CONDITION(m.m_iLock == 0) ; ASSERT_CONDITION(Atomic::Swap(m.m_iLock, 1) == 0) ; ASSERT_CONDITION(m.m_iLock == 1) ; ASSERT_CONDITION(Atomic::Swap(m.m_iLock, 0) == 1) ; ASSERT_CONDITION(m.m_iLock == 0) ; ASSERT_CONDITION(Atomic::Swap(m.m_iLock, 1) == 0) ; ASSERT_CONDITION(m.m_iLock == 1) ; return true ; }
bool TestSuite::TestListDSPtr() { printf("\n Running TestListDS PTR...") ; upan::list<int*> l ; l.push_back(new int(100)) ; l.push_back(new int(200)) ; l.push_back(new int(300)) ; l.insert(++l.begin(), new int(400)) ; int arr[ ] = { 100, 400, 200, 300 } ; int i = 0 ; for(auto it : l) ASSERT_CONDITION(arr[ i++ ] == *it); ASSERT_CONDITION(l.size() == 4) ; int* v = l.front(); ASSERT_CONDITION(*v == 100) ; l.pop_front(); delete v ; ASSERT_CONDITION(l.size() == 3); ASSERT_CONDITION(*l.front() == 400); ASSERT_CONDITION(*l.back() == 300); i = 1; for(auto it = l.begin(); it != l.end();) { ASSERT_CONDITION(arr[ i++ ] == **it); delete *it; l.erase(it++); } ASSERT_CONDITION(l.size() == 0); return true ; }
// Moves to the closest target (appending the motion). // Returns whether a motion was successfully found. // Updates source to the target selected. // Removes said target from targets. bool BufferingPlayer::move_to_closest_target(Reference_point& source, Reference_point_vec& targets, Motion& motion) { TIMED_TRACE_ENTER("move_to_closest_target"); CGAL_precondition(!env->get_target_configurations().empty()); Ref_p_vec::iterator target_reached; int target_index; // Plan a motion to the closest remaining target bool path_found = planner.query_closest_point( source, targets, target_index, // Append it to the output motion motion); ASSERT_CONDITION(path_found, "targets are connected but could not find path!"); // Reached another target target_reached = targets.begin() + target_index; source = *target_reached; targets.erase(target_reached); TIMED_TRACE_EXIT("move_to_closest_target"); return true; }
void test_remove_node(const int size, const int node_index) { // initialize the list Node<int> *head = new Node<int>; head->next = NULL; head->data = 0; Node<int> *curr = head; for (int i = 1; i < size; ++i) { curr->next = new Node<int>; curr = curr->next; curr->next = NULL; curr->data = i; } // get the node we want to delete curr = head; for (int i = 0; i < node_index; ++i) curr = curr->next; // run the algorithm remove_node(curr); // check data values curr = head; for (int i = 0; i < size; ++i) { if (i != node_index) { ASSERT_CONDITION(curr->data == i, "verify node values"); curr = curr->next; } } // cleanup for (int i = 0; i < size - 1; ++i) { curr = head; head = head->next; delete curr; } }
int main() { ASSERT_CONDITION(compute_parity_linear_in_bits(0) == 0, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(1) == 1, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(2) == 1, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(3) == 0, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(4) == 1, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(5) == 0, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(6) == 0, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_bits(7) == 1, "linear in number of bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(8) == 1, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(9) == 0, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(10) == 0, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(11) == 1, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(12) == 0, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(13) == 1, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(14) == 1, "linear in number of set bits"); ASSERT_CONDITION(compute_parity_linear_in_set_bits(15) == 0, "linear in number of set bits"); precompute_parity(); ASSERT_CONDITION(compute_parity_lookup(256) == 1, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(257) == 0, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(258) == 0, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(259) == 1, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(260) == 0, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(261) == 1, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(262) == 1, "lookup table"); ASSERT_CONDITION(compute_parity_lookup(263) == 0, "lookup table"); return 0; }
int main() { std::cerr << "Running Test for Disjoint Set..." << std::endl; DisjointSet<int> test; for (int i = 0; i < 10; ++i) test.add(i); for (int i = 0; i < 9; ++i) { for (int j = i + 1; j < 10; ++j) { ASSERT_CONDITION(test.isConnected(i, j) == false, "No connectivity check"); } } ASSERT_CONDITION(test.getNumElements() == 10, "Number of elements check"); ASSERT_CONDITION(test.getNumSets() == 10, "Number of sets check"); test.merge(1, 2); test.merge(1, 5); test.merge(2, 6); test.merge(8, 5); test.merge(3, 4); test.merge(9, 7); ASSERT_CONDITION(test.getNumElements() == 10, "Number of elements (after merge) check"); ASSERT_CONDITION(test.getNumSets() == 4, "Number of sets (after merge) check"); ASSERT_CONDITION(test.isConnected(1, 2) == true, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(1, 5) == true, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(1, 6) == true, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(1, 8) == true, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(3, 4) == true, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(7, 9) == true, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(0, 1) == false, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(0, 3) == false, "Connectivity (after merge) check"); ASSERT_CONDITION(test.isConnected(0, 7) == false, "Connectivity (after merge) check"); return 0; }
int main() { std::unordered_map<unsigned int, unsigned long long> cache; cache[1] = 1; cache[2] = 2; cache[3] = 4; ASSERT_CONDITION(climb_stairs_with_cache(4, cache) == 7, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(5, cache) == 13, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(6, cache) == 24, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(7, cache) == 44, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(8, cache) == 81, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(25, cache) == 2555757, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(30, cache) == 53798080, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(35, cache) == 1132436852, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(50, cache) == 10562230626642, "with cache"); ASSERT_CONDITION(climb_stairs_with_cache(100, cache) == 7367864567128947527, "with cache"); ASSERT_CONDITION(climb_stairs(4) == 7, "no cache"); ASSERT_CONDITION(climb_stairs(5) == 13, "no cache"); ASSERT_CONDITION(climb_stairs(6) == 24, "no cache"); ASSERT_CONDITION(climb_stairs(7) == 44, "no cache"); ASSERT_CONDITION(climb_stairs(8) == 81, "no cache"); ASSERT_CONDITION(climb_stairs(25) == 2555757, "no cache"); ASSERT_CONDITION(climb_stairs(30) == 53798080, "no cache"); ASSERT_CONDITION(climb_stairs(35) == 1132436852, "no cache"); return 0; }