reachability-algorithms/test/algorithm_test.cc

#include <doctest/doctest.h>

#include "algorithm/tarjan.h"
#include "algorithm/breadth_first_search.h"

#include <random>
#include <functional>
constexpr int verticesNum = 10;

#include <iostream>

using namespace graph;

TEST_SUITE("Algorithm") {

  TEST_CASE("Tarjan::execute") {
    // 1 --> 2 --> 3 --> 1
    //             3 --> 4 --> 5 --> 3
    //       2 --> 6 --> 7 --> 8 --> 6
    //                   7 --> 9
    //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
    //                                       12 --> 10
    Digraph<std::uint16_t> G;
    G.insert(1, 2);
    G.insert(2, 3);
    G.insert(3, 1);
    G.insert(3, 4);
    G.insert(4, 5);
    G.insert(5, 3);
    G.insert(2, 6);
    G.insert(6, 7);
    G.insert(7, 8);
    G.insert(7, 9);
    G.insert(8, 6);
    G.insert(6, 9);
    G.insert(9, 10);
    G.insert(10, 11);
    G.insert(11, 12);
    G.insert(12, 13);
    G.insert(13, 9);
    G.insert(12, 10);

    REQUIRE_EQ(G.V(), 13);

    auto SCCs = algo::Tarjan<std::uint16_t>(G.adjList).execute();

    std::vector<std::vector<std::uint16_t>> expected = {
      {9, 10, 11, 12, 13},
      {6, 7, 8},
      {1, 2, 3, 4, 5}
    };

    for (auto i = 0; i < SCCs.size(); i++) {
      auto kv = std::views::keys(SCCs[i].adjList);
      CHECK_EQ(std::is_permutation(kv.begin(), kv.end(),
                                   expected[i].begin()), true);
    }
  }

  TEST_CASE("Tarjan::execute ~ DAG") {
    Digraph<std::uint16_t> G;
    auto gen = std::bind(std::uniform_real_distribution<>(0, 1), std::default_random_engine());

    for (int i = 0; i <= verticesNum; ++i) {
      for (int j = i + 1; j <= verticesNum; ++j) {
        if (gen() < 0.25) G.insert(i, j);
      }
    }

    auto SCCs = algo::Tarjan<std::uint16_t>(G.adjList).execute();

    // Testing whether an scc is a 1-vertex scc which after the normalization
    // has no edges, in this case we know tgat there exist no 2-vertex sccs
    for (auto& scc : SCCs) {
      CHECK_EQ(std::all_of(scc.adjList.begin(), scc.adjList.end(),
                           [](const auto& p) {
                             return p.second.size() == 0;
                           }), true);
    }
  }
  
  TEST_CASE("BreadthFirstSearch::execute") {
    // 1 --> 2 --> 3 --> 1
    //             3 --> 4 --> 5 --> 3
    //       2 --> 6 --> 7 --> 8 --> 6
    //                   7 --> 9
    //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
    //                                       12 --> 10
    Digraph<std::uint16_t> G;
    G.insert(1, 2);
    G.insert(2, 3);
    G.insert(3, 1);
    G.insert(3, 4);
    G.insert(4, 5);
    G.insert(5, 3);
    G.insert(2, 6);
    G.insert(6, 7);
    G.insert(7, 8);
    G.insert(7, 9);
    G.insert(8, 6);
    G.insert(6, 9);
    G.insert(9, 10);
    G.insert(10, 11);
    G.insert(11, 12);
    G.insert(12, 13);
    G.insert(13, 9);
    G.insert(12, 10);

    auto tree =
      algo::BreadthFirstSearch<std::uint16_t>(G.adjList).execute(1);

    std::unordered_map<std::uint16_t, 
      std::unordered_set<std::uint16_t>> expected = {
      {1, {2}},
      {2, {3, 6}},
      {3, {4}},
      {4, {5}},
      {5, {}},
      {6, {7, 9}},
      {7, {8}},
      {8, {}},
      {9, {10}},
      {10, {11}},
      {11, {12}},
      {12, {13}},
      {13, {}}
    };

    CHECK_EQ(tree, expected);
  }

  TEST_CASE("BreadthFirstSearch::query") {
    // 1 --> 2 --> 3 --> 1
    //             3 --> 4 --> 5 --> 3
    //       2 --> 6 --> 7 --> 8 --> 6
    //                   7 --> 9
    //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
    //                                       12 --> 10
    Digraph<std::uint16_t> G;
    G.insert(1, 2);
    G.insert(2, 3);
    G.insert(3, 1);
    G.insert(3, 4);
    G.insert(4, 5);
    G.insert(5, 3);
    G.insert(2, 6);
    G.insert(6, 7);
    G.insert(7, 8);
    G.insert(7, 9);
    G.insert(8, 6);
    G.insert(6, 9);
    G.insert(9, 10);
    G.insert(10, 11);
    G.insert(11, 12);
    G.insert(12, 13);
    G.insert(13, 9);
    G.insert(12, 10);

    algo::BreadthFirstSearch<std::uint16_t> bfs(G.adjList);

    CHECK_EQ(bfs.query(1, 5), true);
    CHECK_EQ(bfs.query(1, 10), true);
    CHECK_EQ(bfs.query(9, 5), false);
    CHECK_EQ(bfs.query(8, 4), false);
  }
}