testSchulze.cpp | searchcode

/tests/testSchulze.cpp

https://bitbucket.org/capitol/schulze
C++ | 543 lines | 422 code | 103 blank | 18 comment | 48 complexity | a20ba5a3a1043e647ee63d3f22bd41dc MD5 | raw file

/*
    libschulze, a library that implements the schulze voting algorithm
    Copyright (C) 2013  Alexander KjÃ¤ll

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "../src/candidate.h"
#include "../src/ranking.h"
#include "../src/schulze.h"

#include <boost/test/unit_test.hpp>
#include <list>
#include <vector>

BOOST_AUTO_TEST_CASE(CheckSchulzeEmptyInput) {
  Ranking rank1;
  std::vector<Candidate<int>> clist;
  
  std::list<Ranking> rlist = { rank1 };
  
  Schulze s;

  VoteResult expResult;

  VoteResult result = s.calc(rlist, clist);

  BOOST_CHECK_EQUAL(expResult, result);
}  

BOOST_AUTO_TEST_CASE(CheckSchulzeTwoCandidatesTwoRanks) {
  Candidate<int> c1(0, 0, "c1"), c2(1, 1, "c2");
  Ranking rank1, rank2{ c1, c2 };

  rank1.setRank(c1, 1);
  rank1.setRank(c2, 1);

  std::vector<Candidate<int>> clist { c1, c2 };
  
  std::list<Ranking> rlist = { rank1, rank2 };
  
  Schulze s;

  VoteResult expResult { c1, c2 };

  VoteResult result = s.calc(rlist, clist);

  BOOST_CHECK_EQUAL(expResult, result);
}  

void rankWikipedia(Ranking* ranks, Candidate<int>& cA, Candidate<int>& cB, Candidate<int>& cC, Candidate<int>& cD, Candidate<int>& cE) {
  int tot = 0;
  for(int i = 0; i < 5; i++, tot++) {
    ranks[tot].setRank(cA, 0);
    ranks[tot].setRank(cC, 1);
    ranks[tot].setRank(cB, 2);
    ranks[tot].setRank(cE, 3);
    ranks[tot].setRank(cD, 4);
  }
  for(int i = 0; i < 5; i++, tot++) {
    ranks[tot].setRank(cA, 0);
    ranks[tot].setRank(cD, 1);
    ranks[tot].setRank(cE, 2);
    ranks[tot].setRank(cC, 3);
    ranks[tot].setRank(cB, 4);
  }
  for(int i = 0; i < 8; i++, tot++) {
    ranks[tot].setRank(cB, 0);
    ranks[tot].setRank(cE, 1);
    ranks[tot].setRank(cD, 2);
    ranks[tot].setRank(cA, 3);
    ranks[tot].setRank(cC, 4);
  }
  for(int i = 0; i < 3; i++, tot++) {
    ranks[tot].setRank(cC, 0);
    ranks[tot].setRank(cA, 1);
    ranks[tot].setRank(cB, 2);
    ranks[tot].setRank(cE, 3);
    ranks[tot].setRank(cD, 4);
  }
  for(int i = 0; i < 7; i++, tot++) {
    ranks[tot].setRank(cC, 0);
    ranks[tot].setRank(cA, 1);
    ranks[tot].setRank(cE, 2);
    ranks[tot].setRank(cB, 3);
    ranks[tot].setRank(cD, 4);
  }
  for(int i = 0; i < 2; i++, tot++) {
    ranks[tot].setRank(cC, 0);
    ranks[tot].setRank(cB, 1);
    ranks[tot].setRank(cA, 2);
    ranks[tot].setRank(cD, 3);
    ranks[tot].setRank(cE, 4);
  }
  for(int i = 0; i < 7; i++, tot++) {
    ranks[tot].setRank(cD, 0);
    ranks[tot].setRank(cC, 1);
    ranks[tot].setRank(cE, 2);
    ranks[tot].setRank(cB, 3);
    ranks[tot].setRank(cA, 4);
  }
  for(int i = 0; i < 8; i++, tot++) {
    ranks[tot].setRank(cE, 0);
    ranks[tot].setRank(cB, 1);
    ranks[tot].setRank(cA, 2);
    ranks[tot].setRank(cD, 3);
    ranks[tot].setRank(cC, 4);
  }
}

BOOST_AUTO_TEST_CASE(CheckSchulzeWikipediaExample) {
  Candidate<int> cA(0, 0, "cA"), cB(1, 1, "cB"), cC(2, 2, "cC"), cD(3, 3, "cD"), cE(4, 4, "cE");
  Ranking ranks[45];
  rankWikipedia(ranks, cA, cB, cC, cD, cE);
  
  std::vector<Candidate<int>> clist { cA, cB, cC, cD, cE };
  
  std::list<Ranking> rlist(std::begin(ranks), std::end(ranks));
  
  Schulze s;

  VoteResult result = s.calc(rlist, clist);

  VoteResult expResult { cE, cA, cC, cB, cD };
  
  BOOST_CHECK_EQUAL(expResult, result);
}  

BOOST_AUTO_TEST_CASE(CheckSchulzeWorkshopExample) {
  Candidate<int> cA(0, 0), cB(1, 1), cC(2, 2), cD(3, 3), cE(4, 4), cF(5, 5), cG(6, 6), cH(7, 7);
  Ranking ranks[7] { 
    { std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cC, cE } },
    { std::vector<Candidate<int> >{ cA, cB, cC, cD, cE, cF, cG, cH } },
    { std::vector<Candidate<int> >{ cC, cD, cE, cF, cG, cH }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cB } },
    { std::vector<Candidate<int> >{ cD, cF }, std::vector<Candidate<int> >{ cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cC, cE, cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cB, cC }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cE } }
  };

  std::vector<Candidate<int>> clist { cA, cB, cC, cD, cE, cF, cG, cH };
  
  std::list<Ranking> rlist(std::begin(ranks), std::end(ranks));
  
  Schulze s;

  VoteResult expResult { cD, cG, cF, cB, cA, cC, cE, cH };

  VoteResult result = s.calc(rlist, clist);

  BOOST_CHECK_EQUAL(expResult, result);
  
  auto i = clist.begin();
  BOOST_CHECK_EQUAL(6, i->getVictories());
  BOOST_CHECK_EQUAL(3, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(6, i->getVictories());
  BOOST_CHECK_EQUAL(6, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(5, i->getVictories());
  BOOST_CHECK_EQUAL(5, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(4, i->getVictories());
  BOOST_CHECK_EQUAL(1, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(3, i->getVictories());
  BOOST_CHECK_EQUAL(0, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(1, i->getVictories());
  BOOST_CHECK_EQUAL(2, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(1, i->getVictories());
  BOOST_CHECK_EQUAL(4, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(0, i->getVictories());
  BOOST_CHECK_EQUAL(7, i->getIndex());
}  

BOOST_AUTO_TEST_CASE(CheckSchulzeWorkshopExample2) {
  Candidate<int> cA(0, 0), cB(1, 1), cC(2, 2), cD(3, 3), cE(4, 4), cF(5, 5), cG(6, 6), cH(7, 7);
  Ranking ranks[] { 
    { std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cC, cE } },
    { std::vector<Candidate<int> >{ cA, cB, cC, cD, cE, cF, cG, cH } },
    { std::vector<Candidate<int> >{ cC, cD, cE, cF, cG, cH }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cB } },
    { std::vector<Candidate<int> >{ cD, cF }, std::vector<Candidate<int> >{ cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cC, cE, cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cB, cC }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cE } },
    { std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cC, cE } },
    { std::vector<Candidate<int> >{ cA, cB, cC, cD, cE, cF, cG, cH } },
    { std::vector<Candidate<int> >{ cC, cD, cE, cF, cG, cH }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cB } },
    { std::vector<Candidate<int> >{ cD, cF }, std::vector<Candidate<int> >{ cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cC, cE, cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cB, cC }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cE } }
  };

  std::vector<Candidate<int>> clist { cA, cB, cC, cD, cE, cF, cG, cH };
  
  std::list<Ranking> rlist(std::begin(ranks), std::end(ranks));
  
  Schulze s;

  VoteResult expResult { cD, cG, cF, cB, cA, cC, cE, cH };

  VoteResult result = s.calc(rlist, clist);

  BOOST_CHECK_EQUAL(expResult, result);
  
  auto i = clist.begin();
  BOOST_CHECK_EQUAL(6, i->getVictories());
  BOOST_CHECK_EQUAL(3, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(6, i->getVictories());
  BOOST_CHECK_EQUAL(6, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(5, i->getVictories());
  BOOST_CHECK_EQUAL(5, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(4, i->getVictories());
  BOOST_CHECK_EQUAL(1, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(3, i->getVictories());
  BOOST_CHECK_EQUAL(0, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(1, i->getVictories());
  BOOST_CHECK_EQUAL(2, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(1, i->getVictories());
  BOOST_CHECK_EQUAL(4, i->getIndex());
  i++;
  BOOST_CHECK_EQUAL(0, i->getVictories());
  BOOST_CHECK_EQUAL(7, i->getIndex());
}  

struct SchulzeExposer : Schulze {
  using Schulze::calcDefeats;
  using Schulze::determineWinner;
  using Schulze::randomizeEqualPositions;
};

BOOST_AUTO_TEST_CASE(CheckRandomize) {
  std::vector<Candidate<int>> v { Candidate<int>(0, 0), Candidate<int>(1, 1), Candidate<int>(2, 2), Candidate<int>(3, 3) };

  v[0].setVictories(1);
  v[1].setVictories(2);
  v[2].setVictories(2);
  v[3].setVictories(4);

  Schulze s;
  (s.*&SchulzeExposer::randomizeEqualPositions)(v);

  BOOST_CHECK(v[0].getIndex() == 0);
  BOOST_CHECK(v[1].getIndex() == 1 || v[1].getIndex() == 2);
  BOOST_CHECK(v[2].getIndex() == 1 || v[2].getIndex() == 2);
  BOOST_CHECK(v[3].getIndex() == 3);
}

BOOST_AUTO_TEST_CASE(CheckRandomizeTwoPlateaus) {
  std::vector<Candidate<int>> v { Candidate<int>(0, 0), Candidate<int>(1, 1), Candidate<int>(2, 2), Candidate<int>(3, 3), Candidate<int>(4, 4), Candidate<int>(5, 5), Candidate<int>(6, 6), Candidate<int>(7, 7) };
  
  v[0].setVictories(1);
  v[1].setVictories(2);
  v[2].setVictories(2);
  v[3].setVictories(4);
  v[4].setVictories(4);
  v[5].setVictories(4);
  v[6].setVictories(5);
  v[7].setVictories(6);
  
  Schulze s;
  (s.*&SchulzeExposer::randomizeEqualPositions)(v);
  
  BOOST_CHECK(v[0].getIndex() == 0);
  BOOST_CHECK(v[1].getIndex() == 1 || v[1].getIndex() == 2);
  BOOST_CHECK(v[2].getIndex() == 1 || v[2].getIndex() == 2);
  BOOST_CHECK(v[3].getIndex() == 3 || v[3].getIndex() == 4 || v[3].getIndex() == 5);
  BOOST_CHECK(v[4].getIndex() == 3 || v[4].getIndex() == 4 || v[4].getIndex() == 5);
  BOOST_CHECK(v[5].getIndex() == 3 || v[5].getIndex() == 4 || v[5].getIndex() == 5);
  BOOST_CHECK(v[6].getIndex() == 6);
  BOOST_CHECK(v[7].getIndex() == 7);
}

BOOST_AUTO_TEST_CASE(CheckCalcDefeats) {
  Candidate<int> c1(0, 0), c2(1, 1);
  Ranking rank1, rank2 {c1, c2};

  rank1.setRank(c1, 1);
  rank1.setRank(c2, 1);

  std::vector<Candidate<int>> clist { c1, c2 };
  
  std::list<Ranking> rlist = { rank1, rank2 };

  Schulze s;
  Graph result = (s.*&SchulzeExposer::calcDefeats)(rlist, clist);

  BOOST_CHECK_EQUAL(2, boost::num_vertices(result));
  BOOST_CHECK_EQUAL(4, boost::num_edges(result));

  Edge e1, e2;
  bool ee1, ee2;

  boost::tie(e1, ee1) = boost::edge(c1.getIndex(), c2.getIndex(), result);
  boost::tie(e2, ee2) = boost::edge(c2.getIndex(), c1.getIndex(), result);

  BOOST_CHECK(ee1 && ee2);

  BOOST_CHECK_EQUAL(1, result[e1].defeats);
  BOOST_CHECK_EQUAL(0, result[e2].defeats);
}

BOOST_AUTO_TEST_CASE(CheckCalcDefeatsWikipediaExample) {
  Candidate<int> cA(0, 0), cB(1, 1), cC(2, 2), cD(3, 3), cE(4, 4);
  Ranking ranks[45];
  rankWikipedia(ranks, cA, cB, cC, cD, cE);
  
  std::vector<Candidate<int>> clist { cA, cB, cC, cD, cE };
  
  std::list<Ranking> rlist(std::begin(ranks), std::end(ranks));

  Schulze s;
  Graph result = (s.*&SchulzeExposer::calcDefeats)(rlist, clist);

  BOOST_CHECK_EQUAL(5, boost::num_vertices(result));
  BOOST_CHECK_EQUAL(25, boost::num_edges(result));

  Edge e;
  bool ee;
  int expResult[] = { 0, 20, 26, 30 ,22,
                      25, 0, 16, 33, 18,
                      19, 29, 0, 17, 24,
                      15, 12, 28, 0, 14,
                      23, 27, 21, 31, 0 };

  for(int i = 0; i < 25; ++i) {
    if(i % 5 != i / 5) {
      boost::tie(e, ee) = boost::edge(i / 5, i % 5, result);

      BOOST_CHECK(ee);
      BOOST_CHECK_EQUAL(expResult[i], result[e].defeats);
    }
  }
}

BOOST_AUTO_TEST_CASE(CheckCalcDefeatsWorkshopExample) {
  Candidate<int> cA(0, 0), cB(1, 1), cC(2, 2), cD(3, 3), cE(4, 4), cF(5, 5), cG(6, 6), cH(7, 7);
  Ranking ranks[7] { 
    { std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cC, cE } },
    { std::vector<Candidate<int> >{ cA, cB, cC, cD, cE, cF, cG, cH } },
    { std::vector<Candidate<int> >{ cC, cD, cE, cF, cG, cH }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cB } },
    { std::vector<Candidate<int> >{ cD, cF }, std::vector<Candidate<int> >{ cG }, std::vector<Candidate<int> >{ cB }, std::vector<Candidate<int> >{ cA }, std::vector<Candidate<int> >{ cC, cE, cH } },
    { std::vector<Candidate<int> >{ cD, cG }, std::vector<Candidate<int> >{ cA, cF }, std::vector<Candidate<int> >{ cB, cC }, std::vector<Candidate<int> >{ cH }, std::vector<Candidate<int> >{ cE } }
  };
  
  ranks[0].setRank(cH, 1);
  
  ranks[1].setRank(cA, 1);
  ranks[1].setRank(cH, 2);
  
  ranks[2].setRank(cA, 7);
  ranks[2].setRank(cB, 2);
  ranks[2].setRank(cC, 8);
  ranks[2].setRank(cD, 1);
  ranks[2].setRank(cE, 8);
  ranks[2].setRank(cF, 7);
  ranks[2].setRank(cG, 1);
  
  ranks[3].setRank(cA, 1);
  ranks[3].setRank(cB, 1);
  ranks[3].setRank(cC, 1);
  ranks[3].setRank(cD, 1);
  ranks[3].setRank(cE, 1);
  ranks[3].setRank(cF, 1);
  ranks[3].setRank(cG, 1);
  ranks[3].setRank(cH, 1);
  
  ranks[4].setRank(cA, 2);
  ranks[4].setRank(cB, 4);
  ranks[4].setRank(cC, 1);
  ranks[4].setRank(cD, 1);
  ranks[4].setRank(cE, 1);
  ranks[4].setRank(cF, 1);
  ranks[4].setRank(cG, 1);
  ranks[4].setRank(cH, 3);
  
  ranks[5].setRank(cA, 7);
  ranks[5].setRank(cB, 3);
  ranks[5].setRank(cC, 8);
  ranks[5].setRank(cD, 1);
  ranks[5].setRank(cE, 8);
  ranks[5].setRank(cF, 1);
  ranks[5].setRank(cG, 2);
  ranks[5].setRank(cH, 8);
  
  ranks[6].setRank(cA, 2);
  ranks[6].setRank(cB, 4);
  ranks[6].setRank(cC, 4);
  ranks[6].setRank(cD, 1);
  ranks[6].setRank(cE, 8);
  ranks[6].setRank(cF, 2);
  ranks[6].setRank(cG, 1);
  ranks[6].setRank(cH, 5);

  std::vector<Candidate<int>> clist { cA, cB, cC, cD, cE, cF, cG, cH };
  
  std::list<Ranking> rlist(std::begin(ranks), std::end(ranks));
  
  Schulze s;
  Graph result = (s.*&SchulzeExposer::calcDefeats)(rlist, clist);
  
  BOOST_CHECK_EQUAL(8, boost::num_vertices(result));
  BOOST_CHECK_EQUAL(64, boost::num_edges(result));
}

BOOST_AUTO_TEST_CASE(CheckDetermineWinnerWikipediaExample) {
  Graph g;
  
  boost::add_vertex(0, g); // A
  boost::add_vertex(1, g); // B
  boost::add_vertex(2, g); // C
  boost::add_vertex(3, g); // D
  boost::add_vertex(4, g); // E
  

  CandidateRelation rel[20];
  rel[0].strongestPath = 28; // A -> B    A     A 3 win
  rel[1].strongestPath = 28; // A -> C    A     B 1 wins
  rel[2].strongestPath = 30; // A -> D    A     C 2 win
  rel[3].strongestPath = 24; // A -> E    E     D 0 wins
  rel[4].strongestPath = 25; // B -> A          E 4 win
  rel[5].strongestPath = 28; // B -> C    C
  rel[6].strongestPath = 33; // B -> D    B
  rel[7].strongestPath = 24; // B -> E    E
  rel[8].strongestPath = 25; // C -> A
  rel[9].strongestPath = 29; // C -> B
  rel[10].strongestPath = 29; // C -> D   C
  rel[11].strongestPath = 24; // C -> E   E
  rel[12].strongestPath = 25; // D -> A
  rel[13].strongestPath = 28; // D -> B
  rel[14].strongestPath = 28; // D -> C
  rel[15].strongestPath = 24; // D -> E   E
  rel[16].strongestPath = 25; // E -> A
  rel[17].strongestPath = 28; // E -> B
  rel[18].strongestPath = 28; // E -> C
  rel[19].strongestPath = 31; // E -> D

  int c = 0;
  for(int i = 0; i < 5; i++) {
    for(int j = 0; j < 5; j++) {
      if(i != j) {
        boost::add_edge(i, j, rel[c], g);
        c++;
      }
    }
  }

  std::vector<Candidate<int>> l { Candidate<int>(0, 0), Candidate<int>(1, 1), Candidate<int>(2, 2), Candidate<int>(3, 3), Candidate<int>(4, 4) };
  
  Schulze s;
  (s.*&SchulzeExposer::determineWinner)(l, g);

  auto i = l.begin();
  BOOST_CHECK_EQUAL(4, i++->getIndex());
  BOOST_CHECK_EQUAL(0, i++->getIndex());
  BOOST_CHECK_EQUAL(2, i++->getIndex());
  BOOST_CHECK_EQUAL(1, i++->getIndex());
  BOOST_CHECK_EQUAL(3, i++->getIndex());
}

BOOST_AUTO_TEST_CASE(CheckDetermineWinnerTrivialExample) {
  Graph g;
  
  boost::add_vertex(0, g);
  boost::add_vertex(1, g);
  
  CandidateRelation rel[2];
  rel[0].strongestPath = 3;
  rel[1].strongestPath = 5;

  boost::add_edge(0, 1, rel[0], g);
  boost::add_edge(1, 0, rel[1], g);

  std::vector<Candidate<int>> l { Candidate<int>(0, 0), Candidate<int>(1, 1) };

  std::srand(0);

  Schulze s;
  (s.*&SchulzeExposer::determineWinner)(l, g);

  auto i = l.begin();
  BOOST_CHECK_EQUAL(1, i++->getIndex());
  BOOST_CHECK_EQUAL(0, i++->getIndex());
}

BOOST_AUTO_TEST_CASE(CheckDetermineWinnerTrivialExampleThree) {
  Graph g;
  
  boost::add_vertex(0, g);
  boost::add_vertex(1, g);
  boost::add_vertex(2, g);
  
  CandidateRelation rel[6];
  rel[0].strongestPath = 1;
  rel[1].strongestPath = 2;
  rel[2].strongestPath = 3;
  rel[3].strongestPath = 4;
  rel[4].strongestPath = 5;
  rel[5].strongestPath = 6;

  boost::add_edge(0, 1, rel[0], g);
  boost::add_edge(0, 2, rel[1], g);
  boost::add_edge(1, 0, rel[2], g);
  boost::add_edge(1, 2, rel[3], g);
  boost::add_edge(2, 0, rel[4], g);
  boost::add_edge(2, 1, rel[5], g);

  std::vector<Candidate<int>> l { Candidate<int>(0, 0), Candidate<int>(1, 1), Candidate<int>(2, 2) };
  
  std::srand(0);

  Schulze s;
  (s.*&SchulzeExposer::determineWinner)(l, g);

  auto i = l.begin();
  BOOST_CHECK_EQUAL(2, i++->getIndex());
  BOOST_CHECK_EQUAL(1, i++->getIndex());
  BOOST_CHECK_EQUAL(0, i++->getIndex());
}