//=======================================================================

 // Copyright 2001 University of Notre Dame.

 // Author: 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)

 //=======================================================================

 /*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 */

 #include <boost/config.hpp>

 #include <boost/test/minimal.hpp>

 #include <stdlib.h>

 #include <boost/graph/depth_first_search.hpp>

 #include <boost/graph/adjacency_list.hpp>

 #include <boost/graph/graph_archetypes.hpp>

 #include <boost/graph/graph_utility.hpp>

 #include <boost/graph/random.hpp>

 #include <boost/random/mersenne_twister.hpp>

 #ifdef __SYMBIAN32__

 #include "std_log_result.h"

 #define LOG_FILENAME_LINE __FILE__, __LINE__

 #endif

 template <typename ColorMap, typename ParentMap,

   typename DiscoverTimeMap, typename FinishTimeMap>

 class dfs_test_visitor {

   typedef typename boost::property_traits<ColorMap>::value_type ColorValue;

   typedef typename boost::color_traits<ColorValue> Color;

 public:

   dfs_test_visitor(ColorMap color, ParentMap p, DiscoverTimeMap d,

                    FinishTimeMap f)

     : m_color(color), m_parent(p),

     m_discover_time(d), m_finish_time(f), m_time(0) { }

   template <class Vertex, class Graph>

   void initialize_vertex(Vertex u, Graph& g) {

     BOOST_CHECK( boost::get(m_color, u) == Color::white() );

   }

   template <class Vertex, class Graph>

   void start_vertex(Vertex u, Graph& g) {

     BOOST_CHECK( boost::get(m_color, u) == Color::white() );

   }

   template <class Vertex, class Graph>

   void discover_vertex(Vertex u, Graph& g) {

     using namespace boost;

     BOOST_CHECK( get(m_color, u) == Color::gray() );

     BOOST_CHECK( get(m_color, get(m_parent, u)) == Color::gray() );

     put(m_discover_time, u, m_time++);

   }

   template <class Edge, class Graph>

   void examine_edge(Edge e, Graph& g) {

     using namespace boost;

     BOOST_CHECK( get(m_color, source(e, g)) == Color::gray() );

   }

   template <class Edge, class Graph>

   void tree_edge(Edge e, Graph& g) {

     using namespace boost;

     BOOST_CHECK( get(m_color, target(e, g)) == Color::white() );

     put(m_parent, target(e, g), source(e, g));

   }

   template <class Edge, class Graph>

   void back_edge(Edge e, Graph& g) {

     using namespace boost;

     BOOST_CHECK( get(m_color, target(e, g)) == Color::gray() );

   }

   template <class Edge, class Graph>

   void forward_or_cross_edge(Edge e, Graph& g) {

     using namespace boost;

     BOOST_CHECK( get(m_color, target(e, g)) == Color::black() );

   }

   template <class Vertex, class Graph>

   void finish_vertex(Vertex u, Graph& g) {

     using namespace boost;

     BOOST_CHECK( get(m_color, u) == Color::black() );

     put(m_finish_time, u, m_time++);

   }

 private:

   ColorMap m_color;

   ParentMap m_parent;

   DiscoverTimeMap m_discover_time;

   FinishTimeMap m_finish_time;

   typename boost::property_traits<DiscoverTimeMap>::value_type m_time;

 };

 template <typename Graph>

 struct dfs_test

 {

   typedef boost::graph_traits<Graph> Traits;

   typedef typename Traits::vertices_size_type

     vertices_size_type;

   static void go(vertices_size_type max_V) {

     using namespace boost;

     typedef typename Traits::vertex_descriptor vertex_descriptor;

     typedef typename boost::property_map<Graph,

       boost::vertex_color_t>::type ColorMap;

     typedef typename boost::property_traits<ColorMap>::value_type ColorValue;

     typedef typename boost::color_traits<ColorValue> Color;

     vertices_size_type i, k;

     typename Traits::edges_size_type j;

     typename Traits::vertex_iterator vi, vi_end, ui, ui_end;

     boost::mt19937 gen;

     for (i = 0; i < max_V; ++i)

       for (j = 0; j < i*i; ++j) {

         Graph g;

         generate_random_graph(g, i, j, gen);

         ColorMap color = get(boost::vertex_color, g);

         std::vector<vertex_descriptor> parent(num_vertices(g));

         for (k = 0; k < num_vertices(g); ++k)

           parent[k] = k;

         std::vector<int> discover_time(num_vertices(g)),

           finish_time(num_vertices(g));

         dfs_test_visitor<ColorMap, vertex_descriptor*,

           int*, int*> vis(color, &parent[0],

                           &discover_time[0], &finish_time[0]);

         boost::depth_first_search(g, visitor(vis).color_map(color));

         // all vertices should be black

         for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)

           BOOST_CHECK(get(color, *vi) == Color::black());

         // check parenthesis structure of discover/finish times

         // See CLR p.480

         for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)

           for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {

             vertex_descriptor u = *ui, v = *vi;

             if (u != v) {

               BOOST_CHECK( finish_time[u] < discover_time[v]

                           || finish_time[v] < discover_time[u]

                           || (discover_time[v] < discover_time[u]

                                && finish_time[u] < finish_time[v]

                                && boost::is_descendant(u, v, &parent[0]))

                           || (discover_time[u] < discover_time[v]

                                && finish_time[v] < finish_time[u]

                                && boost::is_descendant(v, u, &parent[0]))

                         );

             }

           }

       }

   }

 };

 // usage: dfs.exe [max-vertices=15]

 int test_main(int argc, char* argv[])

 {

   int max_V = 7;

   if (argc > 1)

     max_V = atoi(argv[1]);

   // Test directed graphs.

   dfs_test< boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS,

            boost::property<boost::vertex_color_t, boost::default_color_type> >

     >::go(max_V);

   // Test undirected graphs.

   dfs_test< boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,

            boost::property<boost::vertex_color_t, boost::default_color_type> >

     >::go(max_V);

    #ifdef __SYMBIAN32__

 	std_log(LOG_FILENAME_LINE,"[End Test Case ]");

 	testResultXml("dfs");

 	close_log_file();

 #endif

   return 0;

 }