//======================================================================= // Copyright 2001 University of Notre Dame. // Author: Andrew Janiszewski, Jeremy G. Siek // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) //======================================================================= #include #include #include #include #include #include #include #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP using namespace boost; #endif template < typename DistanceMap, typename ParentMap, typename Graph, typename ColorMap > class bfs_testing_visitor { typedef typename boost::graph_traits< Graph >::vertex_descriptor Vertex; typedef typename boost::graph_traits< Graph >::edge_descriptor Edge; typedef typename boost::color_traits< typename boost::property_traits< ColorMap >::value_type > Color; public: bfs_testing_visitor(Vertex s, DistanceMap d, ParentMap p, ColorMap c) : current_distance(0), distance(d), parent(p), color(c), src(s) { } void initialize_vertex(const Vertex& u, const Graph&) const { BOOST_TEST(get(color, u) == Color::white()); } void examine_vertex(const Vertex& u, const Graph&) const { current_vertex = u; // Ensure that the distances monotonically increase. BOOST_TEST(distance[u] == current_distance || distance[u] == current_distance + 1); if (distance[u] == current_distance + 1) // new level ++current_distance; } void discover_vertex(const Vertex& u, const Graph&) const { BOOST_TEST(get(color, u) == Color::gray()); if (u == src) { current_vertex = src; } else { BOOST_TEST(parent[u] == current_vertex); BOOST_TEST(distance[u] == current_distance + 1); BOOST_TEST(distance[u] == distance[parent[u]] + 1); } } void examine_edge(const Edge& e, const Graph& g) const { BOOST_TEST(source(e, g) == current_vertex); } void tree_edge(const Edge& e, const Graph& g) const { BOOST_TEST(get(color, target(e, g)) == Color::white()); Vertex u = source(e, g), v = target(e, g); BOOST_TEST(distance[u] == current_distance); parent[v] = u; distance[v] = distance[u] + 1; } void non_tree_edge(const Edge& e, const Graph& g) const { BOOST_TEST(color[target(e, g)] != Color::white()); if (boost::is_directed(g)) // cross or back edge BOOST_TEST(distance[target(e, g)] <= distance[source(e, g)] + 1); else { // cross edge (or going backwards on a tree edge) BOOST_TEST(distance[target(e, g)] == distance[source(e, g)] || distance[target(e, g)] == distance[source(e, g)] + 1 || distance[target(e, g)] == distance[source(e, g)] - 1); } } void gray_target(const Edge& e, const Graph& g) const { BOOST_TEST(color[target(e, g)] == Color::gray()); } void black_target(const Edge& e, const Graph& g) const { BOOST_TEST(color[target(e, g)] == Color::black()); // All vertices adjacent to a black vertex must already be discovered typename boost::graph_traits< Graph >::adjacency_iterator ai, ai_end; for (boost::tie(ai, ai_end) = adjacent_vertices(target(e, g), g); ai != ai_end; ++ai) BOOST_TEST(color[*ai] != Color::white()); } void finish_vertex(const Vertex& u, const Graph&) const { BOOST_TEST(color[u] == Color::black()); } private: mutable Vertex current_vertex; mutable typename boost::property_traits< DistanceMap >::value_type current_distance; DistanceMap distance; ParentMap parent; ColorMap color; Vertex src; }; template < class Graph > struct bfs_test { typedef boost::graph_traits< Graph > Traits; typedef typename Traits::vertices_size_type vertices_size_type; static void go(vertices_size_type max_V) { typedef typename Traits::vertex_descriptor vertex_descriptor; typedef boost::color_traits< boost::default_color_type > Color; vertices_size_type i; typename Traits::edges_size_type j; typename Traits::vertex_iterator ui, ui_end; boost::mt19937 gen; for (i = 0; i < max_V; ++i) for (j = 0; j < i * i; ++j) { Graph g; boost::generate_random_graph(g, i, j, gen); // declare the "start" variable vertex_descriptor start = boost::random_vertex(g, gen); // vertex properties std::vector< int > distance( i, (std::numeric_limits< int >::max)()); distance[start] = 0; std::vector< vertex_descriptor > parent(i); for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) parent[*ui] = *ui; std::vector< boost::default_color_type > color(i); // Get vertex index map typedef typename boost::property_map< Graph, boost::vertex_index_t >::const_type idx_type; idx_type idx = get(boost::vertex_index, g); // Make property maps from vectors typedef boost::iterator_property_map< std::vector< int >::iterator, idx_type > distance_pm_type; distance_pm_type distance_pm(distance.begin(), idx); typedef boost::iterator_property_map< typename std::vector< vertex_descriptor >::iterator, idx_type > parent_pm_type; parent_pm_type parent_pm(parent.begin(), idx); typedef boost::iterator_property_map< std::vector< boost::default_color_type >::iterator, idx_type > color_pm_type; color_pm_type color_pm(color.begin(), idx); // Create the testing visitor. bfs_testing_visitor< distance_pm_type, parent_pm_type, Graph, color_pm_type > vis(start, distance_pm, parent_pm, color_pm); boost::breadth_first_search( g, start, visitor(vis).color_map(color_pm)); // All white vertices should be unreachable from the source. for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) if (color[*ui] == Color::white()) { std::vector< boost::default_color_type > color2( i, Color::white()); BOOST_TEST(!boost::is_reachable( start, *ui, g, color_pm_type(color2.begin(), idx))); } // The shortest path to a child should be one longer than // shortest path to the parent. for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) if (parent[*ui] != *ui) // *ui not the root of the bfs tree BOOST_TEST(distance[*ui] == distance[parent[*ui]] + 1); } } }; int main(int argc, char* argv[]) { using namespace boost; int max_V = 7; if (argc > 1) max_V = atoi(argv[1]); bfs_test< adjacency_list< vecS, vecS, directedS > >::go(max_V); bfs_test< adjacency_list< vecS, vecS, undirectedS > >::go(max_V); return boost::report_errors(); }