diff --git a/alib2algo/src/graph/spanningtree/Edmonds.cpp b/alib2algo/src/graph/spanningtree/Edmonds.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac51a91e60dd615228daa38cd825df62ea1f4ceb
--- /dev/null
+++ b/alib2algo/src/graph/spanningtree/Edmonds.cpp
@@ -0,0 +1,254 @@
+/*
+ * Edmonds.cpp
+ *
+ * Created on: Apr 7, 2016
+ * Author: Jan Broz
+ */
+
+#include "Edmonds.h"
+
+#include <vector>
+#include <list>
+#include <queue>
+#include <climits>
+#include <stdexcept>
+
+#include <graph/GraphClasses.h>
+#include "../datastructs/BinomialHeap.h"
+#include "../datastructs/FibonacciHeap.h"
+#include "../datastructs/Components.h"
+#include "../datastructs/Array.h"
+
+#include <exception/AlibException.h>
+
+namespace graph {
+
+namespace spanningtree {
+
+using namespace std;
+
+//====================================================================================================
+// data structures
+
+/// wrapper for directed edge with additional info
+struct Edge {
+ DirectedEdge e;
+ uint from;
+ uint to;
+ int weight;
+ int origWeight;
+ Edge * fParent;
+ vector<Edge*> fChildren;
+ bool deleted;
+
+ Edge( const DirectedEdge & edge, uint from, uint to, int weight )
+ : e(edge), from(from), to(to), weight(weight), origWeight(weight), fParent(NULL), deleted(false) {}
+};
+
+static int compareEdges( Edge * const & e1, Edge * const & e2 )
+{
+ return e2->weight - e1->weight;
+}
+
+class EdgeQueue : public BinomialHeap<Edge*> {
+
+ public:
+
+ EdgeQueue() : BinomialHeap( compareEdges ), offset( 0 ) {}
+ ~EdgeQueue() {}
+
+ void decreaseAll( int amount ) { offset -= amount; }
+
+ Edge * extractMax()
+ {
+ if (size() == 0)
+ return NULL;
+ Edge * edge = BinomialHeap<Edge*>::extractMax();
+ edge->weight += offset;
+ return edge;
+ }
+
+ protected:
+
+ int offset;
+
+};
+
+template< typename Type >
+void vector_remove( vector<Type> & vec, Type elem )
+{
+ for (auto it = vec.begin(); it != vec.end(); it++) {
+ if (*it == elem) {
+ vec.erase( it );
+ break;
+ }
+ }
+}
+
+//====================================================================================================
+// algorithm
+
+static AdjacencyListDirectedGraph edmonds_impl( const DirectedGraph & graph )
+{
+ AdjacencyListDirectedGraph spanningTree; // spanning tree
+
+ uint nodeCnt = graph.nodeCount();
+ uint edgeCnt = graph.edgeCount();
+
+ list<Edge> edges; // just to ease deallocation
+ queue<uint> roots; ///< silne komponenty, ktere jsou koreny v aktualnim grafu (nevede do nich zadny uzel)
+ Array<EdgeQueue> queues( nodeCnt ); ///< vstupni hrany do danych uzlu (razene dle priority)
+ Array<Edge*> enter( nodeCnt ); ///< vstupni hrany do silnych komponent
+ Array<vector<Edge*>> h( nodeCnt ); ///< hrany, ktere mohou byt v kostre
+ vector<uint> rset; ///< rooti vyslednych stromu Tarjanovy implementace
+ Components2 strong( nodeCnt ); ///< silne komponenty (reprezentanti)
+ Components2 weak( nodeCnt ); ///< slabe komponenty (reprezentanti)
+ Array<uint> min( nodeCnt ); ///< urcuje finalni korenove uzly orientovanych koster
+ vector<Edge*> fRoots; ///< koreny lesa F
+ Array<vector<Edge*>> cycles( nodeCnt ); ///< nalezene cykly
+ Array<Edge*> lambda( nodeCnt ); ///< listy lesa F
+
+ // this algorithm works on number identification of nodes and edges
+ std::vector<Node> id2node( nodeCnt );
+ std::vector<DirectedEdge> id2edge( edgeCnt );
+ std::unordered_map<Node,uint> node2id;
+ std::unordered_map<DirectedEdge,uint> edge2id;
+ uint id = 0;
+ for (const Node & node : graph.getNodes()) {
+ id2node[ id ] = node;
+ node2id[ node ] = id;
+ id++;
+ }
+/* id = 0;
+ for (const DirectedEdge & edge : graph.getEdges()) {
+ id2edge[ id ] = edge;
+ edge2id[ edge ] = id;
+ id++;
+ }
+*/
+ // fill up data structures
+ for (uint nodeID = 0; nodeID < nodeCnt; nodeID++) {
+ roots.push( nodeID );
+ enter[ nodeID ] = NULL;
+ min[ nodeID ] = nodeID;
+ strong.MakeSet( nodeID );
+ weak.MakeSet( nodeID );
+ lambda[ nodeID ] = NULL;
+ }
+ for (const DirectedEdge & edge : graph.getEdges()) {
+ int weight;
+ try {
+ weight = graph.getEdgeValue( edge );
+ } catch (const std::out_of_range & ex) {
+ throw exception::AlibException("Edmonds: an edge is missing a capacity");
+ }
+ edges.emplace_back( edge, node2id[ edge.getFromNode() ], node2id[ edge.getToNode() ], weight );
+ queues[ node2id[edge.getToNode()] ].insert( &edges.back() );
+ }
+
+ while (roots.size() != 0) {
+ uint root = roots.front(); roots.pop();
+ Edge * edge = queues[ root ].extractMax();
+ if (edge != NULL) {
+ if (cycles[ strong.Find( root ) ].size() <= 1) {
+ lambda[ root ] = edge;
+ } else if (strong.Find( edge->from ) != strong.Find( edge->to )) {
+ for (Edge * e : cycles[ strong.Find( root ) ]) {
+ vector_remove( fRoots, e ); //je v cyklu, nemuze byt rootem
+ edge->fChildren.push_back( e );
+ e->fParent = edge;
+ }
+ }
+ }
+ if (edge == NULL) {
+ rset.push_back( root ); //pak uzel nema vstupni hranu (je root)
+ } else if (strong.Find( edge->from ) == root) { //nalezli jsme hranu v ramci silne komponenty
+ roots.push( root ); //uzel vratimem do fronty
+ } else {
+ h[ edge->from ].push_back( edge ); //tato hrana je adeptem na hranu MST
+ fRoots.push_back( edge ); //tato hrana je korenem v lese F
+ if (weak.Find( edge->from ) != weak.Find( edge->to )) { //pocatecni a koncovy uzel jsou v ruznych slabych komponentach
+ weak.Union( weak.Find( edge->from ), weak.Find( edge->to ));
+ enter[ root ] = edge; //edge je vstupni hranou do root
+ } else { //pocatecni a koncovy uzel jsou ve stejne slabe komponente
+ Edge * cycleEdge = edge;
+ int maxVal = INT_MIN;
+ int vertex = INT_MIN;
+
+ vector<Edge*> & cycle = cycles[ strong.Find( root ) ];
+ cycle.clear();
+ while (cycleEdge != NULL) { //hledame hranu v cyklu s maximalni vahou (ktera nejvice poskodi cyklus)
+ cycle.push_back( cycleEdge );
+ if (cycleEdge->weight > maxVal) {
+ maxVal = cycleEdge->weight;
+ vertex = strong.Find( cycleEdge->to );
+ }
+ cycleEdge = enter[ strong.Find( cycleEdge->from ) ];
+ }
+ queues[ root ].decreaseAll( edge->weight - maxVal );
+ min[ root ] = min[ vertex ];
+
+ //collapse cycle
+ cycleEdge = enter[ strong.Find( edge->from ) ];
+ while (cycleEdge != NULL) {
+ queues[ strong.Find( cycleEdge->to ) ].decreaseAll( cycleEdge->weight - maxVal ); //pridame prichozim hranam hodnotu, ktera znaci, o kolik se vypustenim dane cyklove hrany a pridanim dane necyklove zhorsi reseni
+ queues[ root ].mergeWith( std::move( queues[ strong.Find( cycleEdge->to ) ] ) );
+ strong.Union( root, strong.Find( cycleEdge->to ) );
+ cycleEdge = enter[ strong.Find( cycleEdge->from ) ];
+ }
+ roots.push( root );
+ }
+ }
+ }
+
+
+ vector<Edge*> b;
+ vector<uint> r;
+ uint fRootIndex = 0;
+
+ while (!rset.empty() || fRootIndex < fRoots.size()) {
+ uint v = 0;
+ if (!rset.empty()) {
+ v = min[ rset[0] ]; rset.erase( rset.begin() );
+ r.push_back(v);
+ } else {
+ Edge * e = fRoots[ fRootIndex ];
+ if (e->deleted) {
+ fRootIndex++;
+ continue;
+ }
+ v = e->to;
+ b.push_back(e);
+ fRootIndex++;
+ }
+ Edge * curr = lambda[ v ];
+ while (curr != NULL && !curr->deleted) {
+ curr->deleted = true;
+ fRoots.insert( fRoots.begin(), curr->fChildren.begin(), curr->fChildren.end() );
+ curr = curr->fParent;
+ }
+ }
+
+ for (const Node & node : graph.getNodes())
+ spanningTree.addNode( node );
+ for (Edge * edge : b)
+ spanningTree.addEdge( edge->e, edge->origWeight );
+
+ return spanningTree;
+}
+
+Graph Edmonds::edmonds( const Graph & graph )
+{
+ return getInstance().dispatch( graph.getData() );
+}
+
+AdjacencyListDirectedGraph Edmonds::edmonds( const DirectedGraph & graph )
+{
+ return edmonds_impl( graph );
+}
+
+auto EdmondsDirectedGraph = Edmonds::RegistratorWrapper< graph::AdjacencyListDirectedGraph, graph::DirectedGraph >( Edmonds::getInstance(), Edmonds::edmonds );
+
+} // spanningtree
+
+} // graph
diff --git a/alib2algo/src/graph/spanningtree/Edmonds.h b/alib2algo/src/graph/spanningtree/Edmonds.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a8f5b9f43086583077c2d13d2986a01264d5a27
--- /dev/null
+++ b/alib2algo/src/graph/spanningtree/Edmonds.h
@@ -0,0 +1,37 @@
+/*
+ * Edmonds.h
+ *
+ * Created on: Apr 7, 2016
+ * Author: Jan Broz
+ */
+
+#ifndef GRAPH_EDMONDS
+#define GRAPH_EDMONDS
+
+#include <core/multipleDispatch.hpp>
+#include <graph/GraphClasses.h>
+
+namespace graph {
+
+namespace spanningtree {
+
+class Edmonds : public std::SingleDispatch< graph::Graph, graph::GraphBase > {
+
+ public:
+
+ static Graph edmonds( const Graph & graph );
+
+ static AdjacencyListDirectedGraph edmonds( const DirectedGraph & graph );
+
+ static Edmonds & getInstance() {
+ static Edmonds res;
+ return res;
+ }
+
+};
+
+} // spanningtree
+
+} // graph
+
+#endif // GRAPH_EDMONDS
diff --git a/alib2algo/src/graph/spanningtree/Kruskal.cpp b/alib2algo/src/graph/spanningtree/Kruskal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..426db198bed96c2385ed802ebc438a39de926321
--- /dev/null
+++ b/alib2algo/src/graph/spanningtree/Kruskal.cpp
@@ -0,0 +1,91 @@
+/*
+ * Kruskal.cpp
+ *
+ * Created on: Mar 26, 2016
+ * Author: Jan Broz
+ */
+
+#include "Kruskal.h"
+
+#include <vector>
+#include <unordered_map>
+#include <algorithm>
+#include <stdexcept>
+
+#include "../datastructs/Components.h"
+#include <exception/AlibException.h>
+
+namespace graph {
+
+namespace spanningtree {
+
+/// wrapper for edges containing weight
+struct WeightedEdge {
+ UndirectedEdge edge;
+ int weight;
+ WeightedEdge( const UndirectedEdge & edge, int weight ) : edge(edge), weight(weight) {}
+};
+
+bool isWeightSmaller( const WeightedEdge & e1, const WeightedEdge & e2)
+{
+ return e1.weight < e2.weight;
+}
+
+/// converts edges to wrappers with assigned weight
+static std::vector<WeightedEdge> getEdges( const UndirectedGraph & graph )
+{
+ std::vector<WeightedEdge> edges;
+ int weight;
+
+ for (const UndirectedEdge & edge : graph.getEdges()) {
+ try {
+ weight = graph.getEdgeValue( edge );
+ } catch (const std::out_of_range & ex) { // when this edge has no value assigned
+ throw exception::AlibException("Kruskal: an edge is missing a weight");
+ }
+ edges.emplace_back( edge, weight );
+ }
+
+ return edges;
+}
+
+static AdjacencyListUndirectedGraph kruskal_impl( const UndirectedGraph & graph )
+{
+ AdjacencyListUndirectedGraph res; // spanning tree
+ std::vector<WeightedEdge> edges; // edges with weights
+ Components comps; // components of the emerging spanning tree
+
+ for (const Node & node : graph.getNodes()) {
+ res.addNode( node );
+ comps.MakeSet( node );
+ }
+
+ edges = getEdges( graph );
+ // sort edges by increasing weight
+ std::sort( edges.begin(), edges.end(), isWeightSmaller );
+
+ for (const WeightedEdge & wedge : edges) { // little easter egg here :D
+ if (comps.Find( wedge.edge.getFirstNode() ) != comps.Find( wedge.edge.getSecondNode() )) { // if both nodes of the edge are in same set, it would create cycle
+ comps.Union( wedge.edge.getFirstNode(), wedge.edge.getSecondNode() );
+ res.addEdge( wedge.edge, wedge.weight );
+ }
+ }
+
+ return res;
+}
+
+Graph Kruskal::kruskal( const Graph & graph )
+{
+ return getInstance().dispatch( graph.getData() );
+}
+
+AdjacencyListUndirectedGraph Kruskal::kruskal( const UndirectedGraph & graph )
+{
+ return kruskal_impl( graph );
+}
+
+auto KruskalUndirectedGraph = Kruskal::RegistratorWrapper< graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph >( Kruskal::getInstance(), Kruskal::kruskal );
+
+} // namespace spanningtree
+
+} // namespace graph
diff --git a/alib2algo/src/graph/spanningtree/Kruskal.h b/alib2algo/src/graph/spanningtree/Kruskal.h
new file mode 100644
index 0000000000000000000000000000000000000000..22609778b89118223f836be83cabba29f132dd07
--- /dev/null
+++ b/alib2algo/src/graph/spanningtree/Kruskal.h
@@ -0,0 +1,37 @@
+/*
+ * Kruskal.h
+ *
+ * Created on: Mar 26, 2016
+ * Author: Jan Broz
+ */
+
+#ifndef GRAPH_KRUSKAL
+#define GRAPH_KRUSKAL
+
+#include <core/multipleDispatch.hpp>
+#include <graph/GraphClasses.h>
+
+namespace graph {
+
+namespace spanningtree {
+
+class Kruskal : public std::SingleDispatch< graph::Graph, graph::GraphBase > {
+
+ public:
+
+ static Graph kruskal( const Graph & graph );
+
+ static AdjacencyListUndirectedGraph kruskal( const UndirectedGraph & graph );
+
+ static Kruskal & getInstance() {
+ static Kruskal res;
+ return res;
+ }
+
+};
+
+} // namespace spanningtree
+
+} // namespace graph
+
+#endif // GRAPH_KRUSKAL
diff --git a/alib2algo/test-src/graph/TestUtils.cpp b/alib2algo/test-src/graph/TestUtils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b03e442a58207ad95960c876f9c6e77a47eefe71
--- /dev/null
+++ b/alib2algo/test-src/graph/TestUtils.cpp
@@ -0,0 +1,40 @@
+#include "TestUtils.h"
+
+#include <unordered_map>
+
+void printGraphData( const graph::DirectedGraph & graph )
+{
+ unsigned int id;
+ std::unordered_map<graph::Node, unsigned int> nodes;
+ std::unordered_map<graph::DirectedEdge, unsigned int> edges;
+ id = 0;
+ for (const graph::Node & node : graph.getNodes()) {
+ nodes[ node ] = id;
+ id++;
+ }
+ id = 0;
+ for (const graph::DirectedEdge & edge : graph.getEdges()) {
+ edges[ edge ] = id;
+ id++;
+ }
+
+ printf("graph data:\n");
+ printf(" node cnt: %lu; edge cnt: %lu\n", graph.nodeCount(), graph.edgeCount());
+ printf(" edges:\n");
+ for (const graph::DirectedEdge & edge : graph.getEdges())
+ printf(" [%u] %u -> %u (%d)\n", edges[edge], nodes[edge.getFromNode()], nodes[edge.getToNode()], graph.getEdgeValue( edge ));
+ printf(" successors:\n");
+ for (const graph::Node & node : graph.getNodes()) {
+ printf(" [%u] ", nodes[node]);
+ for (const graph::Node & succ : graph.successors( node ))
+ printf("%u, ", nodes[succ]);
+ putchar('\n');
+ }
+ printf(" predecessors:\n");
+ for (const graph::Node & node : graph.getNodes()) {
+ printf(" [%u] ", nodes[node]);
+ for (const graph::Node & pred : graph.predecessors( node ))
+ printf("%u, ", nodes[pred]);
+ putchar('\n');
+ }
+}
diff --git a/alib2algo/test-src/graph/TestUtils.h b/alib2algo/test-src/graph/TestUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..97da47f94dcd6be94e07921571b0ad0c837bdcab
--- /dev/null
+++ b/alib2algo/test-src/graph/TestUtils.h
@@ -0,0 +1,26 @@
+#ifndef TEST_UTILS_H
+#define TEST_UTILS_H
+
+#include <cstdio>
+#include <string>
+#include <sstream>
+
+#include <vector>
+#include <unordered_map>
+
+#include <graph/GraphClasses.h>
+
+
+typedef unsigned int uint;
+
+template< typename Type >
+inline std::string toString( const Type & val )
+{
+ std::ostringstream oss;
+ oss << val;
+ return oss.str();
+}
+
+void printGraphData( const graph::DirectedGraph & graph );
+
+#endif // TEST_UTILS_H
diff --git a/alib2algo/test-src/graph/maximumflow/FordFulkersonTest.cpp b/alib2algo/test-src/graph/maximumflow/FordFulkersonTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2487006c357ba8d680d17971df5cdfba23f34a7
--- /dev/null
+++ b/alib2algo/test-src/graph/maximumflow/FordFulkersonTest.cpp
@@ -0,0 +1,224 @@
+#include "FordFulkersonTest.h"
+
+#include <graph/maximumflow/FordFulkerson.h>
+
+#include <exception/AlibException.h>
+
+#include "../TestUtils.h"
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GraphFordFulkersonTest, "graph" );
+CPPUNIT_TEST_SUITE_REGISTRATION( GraphFordFulkersonTest );
+
+
+#define NetworkDef( edgeCount ) const struct { uint nodeCnt; uint edgeCnt; uint source; uint sink; struct { uint node1; uint node2; uint capacity; } edges [ edgeCount ]; }
+#define FlowDef( edgeCount ) const struct { uint edgeCnt; struct { uint node1; uint node2; int flow; } edges [ edgeCount ]; }
+
+NetworkDef(1) network1 = {
+ 2, 1,
+ 0, 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+FlowDef(1) dirflow1 = {
+ 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+FlowDef(1) undirflow1 = {
+ 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+
+//----------------------------------
+NetworkDef(4) network2 = {
+ 4, 4,
+ 0, 3,
+ {
+ { 0, 1, 1 },
+ { 0, 2, 4 },
+ { 1, 3, 2 },
+ { 2, 3, 3 }
+ }
+};
+FlowDef(4) dirflow2 = {
+ 4,
+ {
+ { 0, 1, 1 },
+ { 0, 2, 3 },
+ { 1, 3, 1 },
+ { 2, 3, 3 }
+ }
+};
+FlowDef(4) undirflow2 = {
+ 4,
+ {
+ { 0, 1, 1 },
+ { 0, 2, 3 },
+ { 1, 3, 1 },
+ { 2, 3, 3 }
+ }
+};
+
+//----------------------------------
+NetworkDef(5) network3 = {
+ 4, 5,
+ 0, 3,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 6 },
+ { 1, 2, 2 },
+ { 1, 3, 7 },
+ { 2, 3, 4 }
+ }
+};
+FlowDef(5) dirflow3 = {
+ 5,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 4 },
+ { 1, 2, 0 },
+ { 1, 3, 5 },
+ { 2, 3, 4 }
+ }
+};
+FlowDef(5) undirflow3 = {
+ 5,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 6 },
+ { 1, 2, -2 },
+ { 1, 3, 7 },
+ { 2, 3, 4 }
+ }
+};
+
+//----------------------------------
+NetworkDef(10) network4 = {
+ 7, 10,
+ 0, 6,
+ {
+ { 0, 3, 12 },
+ { 0, 1, 6 },
+ { 1, 3, 2 },
+ { 1, 2, 8 },
+ { 2, 4, 7 },
+ { 3, 4, 1 },
+ { 3, 5, 4 },
+ { 3, 6, 6 },
+ { 4, 6, 7 },
+ { 5, 6, 3 }
+ }
+};
+FlowDef(10) dirflow4 = {
+ 10,
+ {
+ { 0, 3, 10 },
+ { 0, 1, 6 },
+ { 1, 3, 0 },
+ { 1, 2, 6 },
+ { 2, 4, 6 },
+ { 3, 4, 1 },
+ { 3, 5, 3 },
+ { 3, 6, 6 },
+ { 4, 6, 7 },
+ { 5, 6, 3 }
+ }
+};
+FlowDef(10) undirflow4 = {
+ 10,
+ {
+ { 0, 3, 10 },
+ { 0, 1, 6 },
+ { 1, 3, 0 },
+ { 1, 2, 6 },
+ { 2, 4, 6 },
+ { 3, 4, 1 },
+ { 3, 5, 3 },
+ { 3, 6, 6 },
+ { 4, 6, 7 },
+ { 5, 6, 3 }
+ }
+};
+
+
+template< typename Type1, typename Type2 >
+void testDirNetwork( uint netID, const Type1 * netDef, const Type2 * flowDef )
+{
+ graph::AdjacencyListDirectedGraph graph;
+ std::vector<graph::Node> id2node( netDef->nodeCnt );
+ graph::Node source, sink;
+ uint i, j;
+
+ for (i = 0; i < netDef->nodeCnt; i++) {
+ graph::Node node( std::string("n")+toString(i) );
+ graph.addNode( node );
+ id2node[ i ] = node;
+ if (i == netDef->source)
+ source = node;
+ if (i == netDef->sink)
+ sink = node;
+ }
+ for (i = 0; i < netDef->edgeCnt; i++) {
+ graph::DirectedEdge edge( id2node[ netDef->edges[i].node1 ], id2node[ netDef->edges[i].node2 ], std::string("e")+toString(i) );
+ graph.addEdge( edge, netDef->edges[i].capacity );
+ }
+
+ std::cout << "testing network #" << netID << std::endl;
+
+ graph::maximumflow::Flow flow = graph::maximumflow::FordFulkerson::fordfulkerson( graph, source, sink );
+
+ for (uint id = 0; id < flowDef->edgeCnt; id++) {
+ i = flowDef->edges[id].node1;
+ j = flowDef->edges[id].node2;
+ CPPUNIT_ASSERT_EQUAL( flowDef->edges[id].flow, flow[ id2node[i] ][ id2node[j] ] );
+ }
+}
+
+template< typename Type1, typename Type2 >
+void testUndirNetwork( uint netID, const Type1 * netDef, const Type2 * flowDef )
+{
+ graph::AdjacencyListUndirectedGraph graph;
+ std::vector<graph::Node> id2node( netDef->nodeCnt );
+ graph::Node source, sink;
+ uint i, j;
+
+ for (i = 0; i < netDef->nodeCnt; i++) {
+ graph::Node node( std::string("n")+toString(i) );
+ graph.addNode( node );
+ id2node[ i ] = node;
+ if (i == netDef->source)
+ source = node;
+ if (i == netDef->sink)
+ sink = node;
+ }
+ for (i = 0; i < netDef->edgeCnt; i++) {
+ graph::UndirectedEdge edge( id2node[ netDef->edges[i].node1 ], id2node[ netDef->edges[i].node2 ], std::string("e")+toString(i) );
+ graph.addEdge( edge, netDef->edges[i].capacity );
+ }
+
+ std::cout << "testing network #" << netID << std::endl;
+
+ graph::maximumflow::Flow flow = graph::maximumflow::FordFulkerson::fordfulkerson( graph, source, sink );
+
+ for (uint id = 0; id < flowDef->edgeCnt; id++) {
+ i = flowDef->edges[id].node1;
+ j = flowDef->edges[id].node2;
+ CPPUNIT_ASSERT_EQUAL( flowDef->edges[id].flow, flow[ id2node[i] ][ id2node[j] ] );
+ }
+}
+
+void GraphFordFulkersonTest::runTests()
+{
+ testDirNetwork ( 1, &network1, &dirflow1 );
+ testUndirNetwork( 2, &network1, &undirflow1 );
+ testDirNetwork ( 3, &network2, &dirflow2 );
+ testUndirNetwork( 4, &network2, &undirflow2 );
+ testDirNetwork ( 5, &network3, &dirflow3 );
+ testUndirNetwork( 6, &network3, &undirflow3 );
+ testDirNetwork ( 7, &network4, &dirflow4 );
+ testUndirNetwork( 8, &network4, &undirflow4 );
+}
diff --git a/alib2algo/test-src/graph/maximumflow/FordFulkersonTest.h b/alib2algo/test-src/graph/maximumflow/FordFulkersonTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..38ce10f6b39dc95b3e8940ba437a244c1c2612e3
--- /dev/null
+++ b/alib2algo/test-src/graph/maximumflow/FordFulkersonTest.h
@@ -0,0 +1,20 @@
+#ifndef FORD_FULKERSON_TEST_H
+#define FORD_FULKERSON_TEST_H
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class GraphFordFulkersonTest : public CppUnit::TestFixture {
+
+ CPPUNIT_TEST_SUITE( GraphFordFulkersonTest );
+
+ CPPUNIT_TEST( runTests );
+
+ CPPUNIT_TEST_SUITE_END();
+
+ public:
+
+ void runTests();
+
+};
+
+#endif // FORD_FULKERSON_TEST_H
diff --git a/alib2algo/test-src/graph/minimumcut/FordFulkersonTest.cpp b/alib2algo/test-src/graph/minimumcut/FordFulkersonTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ea36f9418301765b8bfda765764cf11e2a054a5
--- /dev/null
+++ b/alib2algo/test-src/graph/minimumcut/FordFulkersonTest.cpp
@@ -0,0 +1,181 @@
+#include "FordFulkersonTest.h"
+
+#include <graph/minimumcut/FordFulkerson.h>
+
+#include <utility>
+
+#include <exception/AlibException.h>
+
+#include "../TestUtils.h"
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GraphFordFulkersonCutTest, "graph" );
+CPPUNIT_TEST_SUITE_REGISTRATION( GraphFordFulkersonCutTest );
+
+
+#define NetworkDef( edgeCount ) const struct { uint nodeCnt; uint edgeCnt; uint source; uint sink; struct { uint node1; uint node2; uint capacity; } edges [ edgeCount ]; }
+struct NodePair {
+ uint node1ID;
+ uint node2ID;
+};
+
+NetworkDef(1) network1 = {
+ 2, 1,
+ 0, 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+NodePair dircut1 [1] = {
+ { 0, 1 }
+};
+NodePair undircut1 [1] = {
+ { 0, 1 }
+};
+
+//----------------------------------
+NetworkDef(4) network2 = {
+ 4, 4,
+ 0, 3,
+ {
+ { 0, 1, 1 },
+ { 0, 2, 4 },
+ { 1, 3, 2 },
+ { 2, 3, 3 }
+ }
+};
+NodePair dircut2 [2] = {
+ { 0, 1 },
+ { 2, 3 }
+};
+NodePair undircut2 [2] = {
+ { 0, 1 },
+ { 2, 3 }
+};
+
+//----------------------------------
+NetworkDef(5) network3 = {
+ 4, 5,
+ 0, 3,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 6 },
+ { 1, 3, 7 },
+ { 2, 1, 2 },
+ { 2, 3, 4 }
+ }
+};
+NodePair dircut3 [2] = {
+ { 0, 1 },
+ { 0, 2 }
+};
+NodePair undircut3 [2] = {
+ { 0, 1 },
+ { 0, 2 }
+};
+
+//----------------------------------
+NetworkDef(10) network4 = {
+ 7, 10,
+ 0, 6,
+ {
+ { 0, 3, 12 },
+ { 0, 1, 6 },
+ { 1, 3, 2 },
+ { 1, 2, 8 },
+ { 2, 4, 7 },
+ { 3, 4, 1 },
+ { 3, 5, 4 },
+ { 3, 6, 6 },
+ { 4, 6, 7 },
+ { 5, 6, 3 }
+ }
+};
+NodePair dircut4 [5] = {
+ { 0, 1 },
+ { 1, 3 },
+ { 3, 4 },
+ { 3, 6 },
+ { 5, 6 }
+};
+NodePair undircut4 [3] = {
+ { 5, 6 },
+ { 3, 6 },
+ { 4, 6 }
+};
+
+
+template< typename Type1, typename Type2 >
+void testDirNetwork( uint netID, const Type1 * netDef, const Type2 cutDef, uint cutSize )
+{
+ graph::AdjacencyListDirectedGraph graph;
+ std::vector<graph::Node> id2node( netDef->nodeCnt );
+ graph::Node source, sink;
+ uint i;
+
+ for (i = 0; i < netDef->nodeCnt; i++) {
+ graph::Node node( std::string("n")+toString(i) );
+ graph.addNode( node );
+ id2node[ i ] = node;
+ if (i == netDef->source)
+ source = node;
+ if (i == netDef->sink)
+ sink = node;
+ }
+ for (i = 0; i < netDef->edgeCnt; i++) {
+ graph::DirectedEdge edge( id2node[ netDef->edges[i].node1 ], id2node[ netDef->edges[i].node2 ], std::string("e")+toString(i) );
+ graph.addEdge( edge, netDef->edges[i].capacity );
+ }
+
+ std::cout << "testing network #" << netID << std::endl;
+
+ graph::minimumcut::Cut cut = graph::minimumcut::FordFulkerson::fordfulkerson( graph, source, sink );
+
+ CPPUNIT_ASSERT_EQUAL( cutSize, (uint)cut.size() );
+ for (uint i = 0; i < cutSize; i++) {
+ CPPUNIT_ASSERT( cut.find( std::make_pair( id2node[cutDef[i].node1ID], id2node[cutDef[i].node2ID] ) ) != cut.end() );
+ }
+}
+
+template< typename Type1, typename Type2 >
+void testUndirNetwork( uint netID, const Type1 * netDef, const Type2 cutDef, uint cutSize )
+{
+ graph::AdjacencyListUndirectedGraph graph;
+ std::vector<graph::Node> id2node( netDef->nodeCnt );
+ graph::Node source, sink;
+ uint i;
+
+ for (i = 0; i < netDef->nodeCnt; i++) {
+ graph::Node node( std::string("n")+toString(i) );
+ graph.addNode( node );
+ id2node[ i ] = node;
+ if (i == netDef->source)
+ source = node;
+ if (i == netDef->sink)
+ sink = node;
+ }
+ for (i = 0; i < netDef->edgeCnt; i++) {
+ graph::UndirectedEdge edge( id2node[ netDef->edges[i].node1 ], id2node[ netDef->edges[i].node2 ], std::string("e")+toString(i) );
+ graph.addEdge( edge, netDef->edges[i].capacity );
+ }
+
+ std::cout << "testing network #" << netID << std::endl;
+
+ graph::minimumcut::Cut cut = graph::minimumcut::FordFulkerson::fordfulkerson( graph, source, sink );
+
+ CPPUNIT_ASSERT_EQUAL( cutSize, (uint)cut.size() );
+ for (uint i = 0; i < cutSize; i++) {
+ CPPUNIT_ASSERT( cut.find( std::make_pair( id2node[cutDef[i].node1ID], id2node[cutDef[i].node2ID] ) ) != cut.end() );
+ }
+}
+
+void GraphFordFulkersonCutTest::runTests()
+{
+ testDirNetwork ( 1, &network1, dircut1, sizeof(dircut1)/sizeof(dircut1[0]) );
+ testUndirNetwork( 2, &network1, undircut1, sizeof(undircut1)/sizeof(undircut1[0]) );
+ testDirNetwork ( 3, &network2, dircut2, sizeof(dircut2)/sizeof(dircut2[0]) );
+ testUndirNetwork( 4, &network2, undircut2, sizeof(undircut2)/sizeof(undircut2[0]) );
+ testDirNetwork ( 5, &network3, dircut3, sizeof(dircut3)/sizeof(dircut3[0]) );
+ testUndirNetwork( 6, &network3, undircut3, sizeof(undircut3)/sizeof(undircut3[0]) );
+ testDirNetwork ( 7, &network4, dircut4, sizeof(dircut4)/sizeof(dircut4[0]) );
+ testUndirNetwork( 8, &network4, undircut4, sizeof(undircut4)/sizeof(undircut4[0]) );
+}
diff --git a/alib2algo/test-src/graph/minimumcut/FordFulkersonTest.h b/alib2algo/test-src/graph/minimumcut/FordFulkersonTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..08e392d4265f7f88fa692b800e135f440ff87410
--- /dev/null
+++ b/alib2algo/test-src/graph/minimumcut/FordFulkersonTest.h
@@ -0,0 +1,20 @@
+#ifndef FORD_FULKERSON_TEST_CUT_H
+#define FORD_FULKERSON_TEST_CUT_H
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class GraphFordFulkersonCutTest : public CppUnit::TestFixture {
+
+ CPPUNIT_TEST_SUITE( GraphFordFulkersonCutTest );
+
+ CPPUNIT_TEST( runTests );
+
+ CPPUNIT_TEST_SUITE_END();
+
+ public:
+
+ void runTests();
+
+};
+
+#endif // FORD_FULKERSON_TEST_CUT_H
diff --git a/alib2algo/test-src/graph/spanningtree/EdmondsTest.cpp b/alib2algo/test-src/graph/spanningtree/EdmondsTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4d14579f912dd2c5605e9a64a6e225cc515608e
--- /dev/null
+++ b/alib2algo/test-src/graph/spanningtree/EdmondsTest.cpp
@@ -0,0 +1,187 @@
+#include "EdmondsTest.h"
+
+#include <graph/spanningtree/Edmonds.h>
+
+#include <graph/generate/RandomGraphFactory.h>
+#include <exception/AlibException.h>
+#include "../TestUtils.h"
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GraphEdmondsTest, "graph" );
+CPPUNIT_TEST_SUITE_REGISTRATION( GraphEdmondsTest );
+
+
+#define GraphDef( edgeCount ) const struct { uint nodeCnt; uint edgeCnt; struct { uint node1; uint node2; uint weight; } edges [ edgeCount ]; }
+
+GraphDef(1) graph1 = {
+ 2, 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+GraphDef(1) spanningTree1 = {
+ 2, 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+
+//----------------------------------
+GraphDef(2) graph2 = {
+ 3, 2,
+ {
+ { 0, 1, 5 },
+ { 1, 2, 6 }
+ }
+};
+GraphDef(2) spanningTree2 = {
+ 3, 2,
+ {
+ { 0, 1, 5 },
+ { 1, 2, 6 }
+ }
+};
+
+//----------------------------------
+GraphDef(2) graph3 = {
+ 3, 2,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 6 }
+ }
+};
+GraphDef(2) spanningTree3 = {
+ 3, 2,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 6 }
+ }
+};
+
+//----------------------------------
+GraphDef(3) graph4 = {
+ 4, 3,
+ {
+ { 0, 1, 5 },
+ { 0, 3, 6 },
+ { 2, 0, 7 }
+ }
+};
+GraphDef(3) spanningTree4 = {
+ 4, 3,
+ {
+ { 0, 1, 5 },
+ { 0, 3, 6 },
+ { 2, 0, 7 }
+ }
+};
+
+//----------------------------------
+GraphDef(3) graph5 = {
+ 3, 3,
+ {
+ { 0, 1, 7 },
+ { 1, 2, 6 },
+ { 1, 2, 5 }
+ }
+};
+GraphDef(2) spanningTree5 = {
+ 3, 2,
+ {
+ { 0, 1, 7 },
+ { 1, 2, 6 },
+ }
+};
+
+//----------------------------------
+GraphDef(5) graph6 = {
+ 4, 5,
+ {
+ { 0, 1, 4 },
+ { 0, 2, 1 },
+ { 0, 3, 2 },
+ { 1, 3, 3 },
+ { 3, 2, 5 }
+ }
+};
+GraphDef(3) spanningTree6 = {
+ 4, 3,
+ {
+ { 0, 2, 1 },
+ { 0, 1, 4 },
+ { 0, 3, 2 }
+ }
+};
+
+//----------------------------------
+GraphDef(10) graph7 = {
+ 6, 10,
+ {
+ { 0, 1, 5 },
+ { 0, 2, 2 },
+ { 0, 4, 1 },
+ { 1, 3, 4 },
+ { 1, 5, 3 },
+ { 2, 3, 2 },
+ { 3, 4, 11 },
+ { 4, 2, 1 },
+ { 4, 1, 8 },
+ { 5, 0, 9 }
+ }
+};
+GraphDef(5) spanningTree7 = {
+ 6, 5,
+ {
+ { 0, 4, 1 },
+ { 4, 2, 1 },
+ { 2, 3, 2 },
+ { 0, 1, 5 },
+ { 1, 5, 3 }
+ }
+};
+
+
+template< typename Type1, typename Type2 >
+void testGraph( uint graphID, const Type1 * graphDef, const Type2 * spanTreeDef )
+{
+ std::vector<graph::Node> id2node( graphDef->nodeCnt );
+ std::vector<graph::DirectedEdge> id2edge( graphDef->edgeCnt );
+ std::unordered_map<graph::Node,uint> node2id;
+ std::unordered_map<graph::DirectedEdge,uint> edge2id;
+
+ graph::AdjacencyListDirectedGraph graph;
+
+ for (uint i = 0; i < graphDef->nodeCnt; i++) {
+ graph::Node node( std::string("n")+toString(i) );
+ graph.addNode( node );
+ id2node[ i ] = node;
+ node2id[ node ] = i;
+ }
+ for (uint i = 0; i < graphDef->edgeCnt; i++) {
+ graph::DirectedEdge edge( id2node[ graphDef->edges[i].node1 ], id2node[ graphDef->edges[i].node2 ], std::string("e")+toString(i) );
+ graph.addEdge( edge, graphDef->edges[i].weight );
+ id2edge[ i ] = edge;
+ edge2id[ edge ] = i;
+ }
+
+ std::cout << "testing spanning tree #" << graphID << std::endl;
+
+ graph::AdjacencyListDirectedGraph spanningTree = graph::spanningtree::Edmonds::edmonds( graph );
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "invalid node count", spanTreeDef->nodeCnt, (uint)spanningTree.nodeCount() );
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "invalid edge count", spanTreeDef->edgeCnt, (uint)spanningTree.edgeCount() );
+ for (uint i = 0; i < spanTreeDef->edgeCnt; i++) {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "missing edge: "+toString(spanTreeDef->edges[i].node1)+","+toString(spanTreeDef->edges[i].node2),
+ true, spanningTree.hasEdge( id2node[ spanTreeDef->edges[i].node1 ], id2node[ spanTreeDef->edges[i].node2 ] ) );
+ }
+}
+
+void GraphEdmondsTest::runTests()
+{
+ testGraph( 1, &graph1, &spanningTree1 );
+ testGraph( 2, &graph2, &spanningTree2 );
+ testGraph( 3, &graph3, &spanningTree3 );
+ testGraph( 4, &graph4, &spanningTree4 );
+ testGraph( 5, &graph5, &spanningTree5 );
+ testGraph( 6, &graph6, &spanningTree6 );
+ testGraph( 7, &graph7, &spanningTree7 );
+}
diff --git a/alib2algo/test-src/graph/spanningtree/EdmondsTest.h b/alib2algo/test-src/graph/spanningtree/EdmondsTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ea95c1c7f906678596bfb96208672aea4b6b677
--- /dev/null
+++ b/alib2algo/test-src/graph/spanningtree/EdmondsTest.h
@@ -0,0 +1,20 @@
+#ifndef EDMONDS_TEST_H
+#define EDMONDS_TEST_H
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class GraphEdmondsTest : public CppUnit::TestFixture {
+
+ CPPUNIT_TEST_SUITE( GraphEdmondsTest );
+
+ CPPUNIT_TEST( runTests );
+
+ CPPUNIT_TEST_SUITE_END();
+
+ public:
+
+ void runTests();
+
+};
+
+#endif // EDMONDS_TEST_H
diff --git a/alib2algo/test-src/graph/spanningtree/KruskalTest.cpp b/alib2algo/test-src/graph/spanningtree/KruskalTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..134becbcc4de1fcd8819c345717189812b0d4bc6
--- /dev/null
+++ b/alib2algo/test-src/graph/spanningtree/KruskalTest.cpp
@@ -0,0 +1,160 @@
+#include "KruskalTest.h"
+
+#include <graph/spanningtree/Kruskal.h>
+
+#include <graph/generate/RandomGraphFactory.h>
+#include <exception/AlibException.h>
+#include "../TestUtils.h"
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GraphKruskalTest, "graph" );
+CPPUNIT_TEST_SUITE_REGISTRATION( GraphKruskalTest );
+
+#define GraphDef( edgeCount ) const struct { uint nodeCnt; uint edgeCnt; struct { uint node1; uint node2; uint weight; } edges [ edgeCount ]; }
+
+GraphDef(1) graph1 = {
+ 2, 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+GraphDef(1) spanningTree1 = {
+ 2, 1,
+ {
+ { 0, 1, 5 }
+ }
+};
+
+//----------------------------------
+GraphDef(3) graph2 = {
+ 3, 3,
+ {
+ { 0, 1, 7 },
+ { 1, 2, 6 },
+ { 1, 2, 5 }
+ }
+};
+GraphDef(2) spanningTree2 = {
+ 3, 2,
+ {
+ { 0, 1, 7 },
+ { 1, 2, 6 },
+ }
+};
+
+//----------------------------------
+GraphDef(5) graph3 = {
+ 4, 5,
+ {
+ { 0, 1, 4 },
+ { 0, 2, 1 },
+ { 0, 3, 2 },
+ { 1, 3, 3 },
+ { 3, 2, 5 }
+ }
+};
+GraphDef(3) spanningTree3 = {
+ 4, 3,
+ {
+ { 0, 2, 1 },
+ { 0, 3, 2 },
+ { 1, 3, 3 }
+ }
+};
+
+GraphDef(24) graph4 = {
+ 12, 24,
+ {
+ { 0, 1, 1 },
+ { 1, 2, 2 },
+ { 2, 3, 2 },
+ { 0, 4, 2 },
+ { 1, 4, 4 },
+ { 1, 5, 3 },
+ { 2, 5, 1 },
+ { 2, 6, 3 },
+ { 3, 6, 4 },
+ { 3, 7, 5 },
+ { 4, 5, 1 },
+ { 5, 6, 5 },
+ { 6, 7, 2 },
+ { 4, 8, 5 },
+ { 4, 9, 2 },
+ { 5, 9, 3 },
+ { 5,10, 4 },
+ { 6,10, 1 },
+ { 6,11, 2 },
+ { 7,11, 5 },
+ { 8, 9, 6 },
+ { 9,10, 2 },
+ {10,11, 4 }
+ }
+};
+GraphDef(11) spanningTree4 = {
+ 12, 11,
+ {
+ { 0, 1, 1 },
+ { 1, 2, 2 },
+ { 2, 3, 2 },
+ { 2, 5, 1 },
+ { 4, 5, 1 },
+ { 6, 7, 2 },
+ { 4, 8, 5 },
+ { 4, 9, 2 },
+ { 6,10, 1 },
+ { 6,11, 3 },
+ { 9,10, 1 }
+ }
+};
+
+
+
+template< typename Type1, typename Type2 >
+void testGraph( uint graphID, const Type1 * graphDef, const Type2 * spanTreeDef )
+{
+ std::vector<graph::Node> id2node( graphDef->nodeCnt );
+ std::vector<graph::UndirectedEdge> id2edge( graphDef->edgeCnt );
+ std::unordered_map<graph::Node,uint> node2id;
+ std::unordered_map<graph::UndirectedEdge,uint> edge2id;
+
+ graph::AdjacencyListUndirectedGraph graph;
+
+ for (uint i = 0; i < graphDef->nodeCnt; i++) {
+ graph::Node node( std::string("n")+toString(i) );
+ graph.addNode( node );
+ id2node[ i ] = node;
+ node2id[ node ] = i;
+ }
+ for (uint i = 0; i < graphDef->edgeCnt; i++) {
+ graph::UndirectedEdge edge( id2node[ graphDef->edges[i].node1 ], id2node[ graphDef->edges[i].node2 ], std::string("e")+toString(i) );
+ graph.addEdge( edge, graphDef->edges[i].weight );
+ id2edge[ i ] = edge;
+ edge2id[ edge ] = i;
+ }
+
+ std::cout << "testing spanning tree #" << graphID << std::endl;
+
+ graph::AdjacencyListUndirectedGraph spanningTree = graph::spanningtree::Kruskal::kruskal( graph );
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "invalid node count", spanTreeDef->nodeCnt, (uint)spanningTree.nodeCount() );
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "invalid edge count", spanTreeDef->edgeCnt, (uint)spanningTree.edgeCount() );
+ for (uint i = 0; i < spanTreeDef->edgeCnt; i++) {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE( "missing edge: "+toString(spanTreeDef->edges[i].node1)+","+toString(spanTreeDef->edges[i].node2),
+ true, spanningTree.hasEdge( id2node[ spanTreeDef->edges[i].node1 ], id2node[ spanTreeDef->edges[i].node2 ] ) );
+ }
+}
+
+void GraphKruskalTest::runTests()
+{
+ testGraph( 1, &graph1, &spanningTree1 );
+ testGraph( 2, &graph2, &spanningTree2 );
+ testGraph( 3, &graph3, &spanningTree3 );
+ testGraph( 4, &graph4, &spanningTree4 );
+
+ std::cout << "testing random big graphs" << std::endl;
+ int nodeCount = 8;
+ for (int i = 0; i < 8; i++) {
+ graph::AdjacencyListUndirectedGraph graph = graph::generate::RandomGraphFactory::generateUndirectedGraph( nodeCount, nodeCount*2 );
+ graph::spanningtree::Kruskal::kruskal( graph );
+ nodeCount *= 2;
+ }
+}
diff --git a/alib2algo/test-src/graph/spanningtree/KruskalTest.h b/alib2algo/test-src/graph/spanningtree/KruskalTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..e84209cbe7ef931e51ca1ab93c188e441506c427
--- /dev/null
+++ b/alib2algo/test-src/graph/spanningtree/KruskalTest.h
@@ -0,0 +1,20 @@
+#ifndef KRUSKAL_TEST_H
+#define KRUSKAL_TEST_H
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class GraphKruskalTest : public CppUnit::TestFixture {
+
+ CPPUNIT_TEST_SUITE( GraphKruskalTest );
+
+ CPPUNIT_TEST( runTests );
+
+ CPPUNIT_TEST_SUITE_END();
+
+ public:
+
+ void runTests();
+
+};
+
+#endif // KRUSKAL_TEST_H