// -*- c++ -*-

 #include <iostream>

 #include <fstream>

 #include <string>

 #include <vector>

 #include <lemon/concept_check.h>

 #include <lemon/concept/heap.h>

 #include <lemon/smart_graph.h>

 #include <lemon/graph_reader.h>

 #include <lemon/bin_heap.h>

 #include <lemon/fib_heap.h>

 #include <lemon/radix_heap.h>

 #include <lemon/linear_heap.h>

 #include "test_tools.h"

 #include "heap_test.h"

 #include <lemon/time_measure.h>

 using namespace lemon;

 using namespace lemon::concept;

 int main() {

   typedef int Item;

   typedef int Prio;

   typedef IntIntMap ItemIntMap;

   typedef ListGraph Graph;

   typedef Graph::Edge Edge;

   typedef Graph::Node Node;

   typedef Graph::EdgeIt EdgeIt;

   typedef Graph::NodeIt NodeIt;

   typedef Graph::EdgeMap<int> LengthMap;

   Graph graph;

   LengthMap length(graph);

   Node start;

   /// \todo create own test graph

   std::string f_name;

   if( getenv("srcdir") )

     f_name = std::string(getenv("srcdir"));

   else f_name = ".";

   f_name += "/dijkstra_test.lgf";

   std::ifstream input(f_name.c_str());

   check(input, "Input file '" << f_name << "' not found.");

   GraphReader<Graph>(input, graph).

     readEdgeMap("capacity", length).

     readNode("source", start).

     run();  

   {

     std::cerr << "Checking Bin Heap" << std::endl;

     typedef BinHeap<Item, Prio, ItemIntMap> IntHeap;

     checkConcept<Heap<Item, Prio, ItemIntMap>, IntHeap>();

     heapSortTest<IntHeap>(100);

     heapIncreaseTest<IntHeap>(100);

     typedef FibHeap<Node, Prio, Graph::NodeMap<int> > NodeHeap;

     checkConcept<Heap<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();

     Timer timer;

     dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);

     std::cout << timer << std::endl;

   }

   {

     std::cerr << "Checking Fib Heap" << std::endl;

     typedef FibHeap<Item, Prio, ItemIntMap> IntHeap;

     checkConcept<Heap<Item, Prio, ItemIntMap>, IntHeap>();

     heapSortTest<IntHeap>(100);

     heapIncreaseTest<IntHeap>(100);

     typedef FibHeap<Node, Prio, Graph::NodeMap<int> > NodeHeap;

     checkConcept<Heap<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();

     Timer timer;

     dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);

     std::cout << timer << std::endl;

   }

   {

     std::cerr << "Checking Radix Heap" << std::endl;

     typedef RadixHeap<Item, ItemIntMap> IntHeap;

     checkConcept<Heap<Item, Prio, ItemIntMap>, IntHeap>();

     heapSortTest<IntHeap>(100);

     heapIncreaseTest<IntHeap>(100);

     typedef RadixHeap<Node, Graph::NodeMap<int> > NodeHeap;

     checkConcept<Heap<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();

     Timer timer;

     dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);

     std::cout << timer << std::endl;

   }

   {

     std::cerr << "Checking Linear Heap" << std::endl;

     typedef LinearHeap<Item, ItemIntMap> IntHeap;

     checkConcept<Heap<Item, Prio, ItemIntMap>, IntHeap>();

     heapSortTest<IntHeap>(100);

     heapIncreaseTest<IntHeap>(100);

     typedef LinearHeap<Node, Graph::NodeMap<int> > NodeHeap;

     checkConcept<Heap<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();

     Timer timer;

     dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);

     std::cout << timer << std::endl;

   }

   std::cout << __FILE__ ": All tests passed.\n";

   return 0;

 }