diff --git a/test/algorithm_test.cc b/test/algorithm_test.cc
index 7079bb5..8f68d4b 100644
--- a/test/algorithm_test.cc
+++ b/test/algorithm_test.cc
@@ -5,10 +5,10 @@
 
 #include <random>
 #include <functional>
-constexpr int verticesNum = 10;
-
 #include <iostream>
 
+constexpr int verticesNum = 10;
+
 using namespace graph;
 
 TEST_SUITE("Algorithm") {
@@ -20,7 +20,7 @@ TEST_SUITE("Algorithm") {
     //                   7 --> 9
     //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
     //                                       12 --> 10
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 3);
     G.insert(3, 1);
@@ -42,9 +42,9 @@ TEST_SUITE("Algorithm") {
 
     REQUIRE_EQ(G.V(), 13);
 
-    auto SCCs = algo::Tarjan<std::uint16_t>(G.adjList).execute();
+    auto SCCs = algo::Tarjan<int>(G.adjList).execute();
 
-    std::vector<std::vector<std::uint16_t>> expected = {
+    std::vector<std::vector<int>> expected = {
       {9, 10, 11, 12, 13},
       {6, 7, 8},
       {1, 2, 3, 4, 5}
@@ -58,8 +58,8 @@ TEST_SUITE("Algorithm") {
   }
 
   TEST_CASE("Tarjan::execute ~ DAG") {
-    Digraph<std::uint16_t> G;
-    auto gen = std::bind(std::uniform_real_distribution<>(0, 1), std::default_random_engine());
+    Digraph<int> G;
+    auto gen = std::bind_front(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) {
@@ -67,7 +67,7 @@ TEST_SUITE("Algorithm") {
       }
     }
 
-    auto SCCs = algo::Tarjan<std::uint16_t>(G.adjList).execute();
+    auto SCCs = algo::Tarjan<int>(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
@@ -86,7 +86,7 @@ TEST_SUITE("Algorithm") {
     //                   7 --> 9
     //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
     //                                       12 --> 10
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 3);
     G.insert(3, 1);
@@ -107,10 +107,10 @@ TEST_SUITE("Algorithm") {
     G.insert(12, 10);
 
     auto tree =
-      algo::BreadthFirstSearch<std::uint16_t>(G.adjList).execute(1);
+      algo::BreadthFirstSearch<int>(G.adjList).execute(1);
 
-    std::unordered_map<std::uint16_t, 
-      std::unordered_set<std::uint16_t>> expected = {
+    std::unordered_map<int, 
+      std::unordered_set<int>> expected = {
       {1, {2}},
       {2, {3, 6}},
       {3, {4}},
@@ -136,7 +136,7 @@ TEST_SUITE("Algorithm") {
     //                   7 --> 9
     //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
     //                                       12 --> 10
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 3);
     G.insert(3, 1);
@@ -156,11 +156,11 @@ TEST_SUITE("Algorithm") {
     G.insert(13, 9);
     G.insert(12, 10);
 
-    algo::BreadthFirstSearch<std::uint16_t> bfs(G.adjList);
+    auto bfs = std::make_unique<algo::BreadthFirstSearch<int>>(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);
+    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);
   }
 }
\ No newline at end of file
diff --git a/test/decremental_reachability_test.cc b/test/decremental_reachability_test.cc
index 252b3dc..d7a4992 100644
--- a/test/decremental_reachability_test.cc
+++ b/test/decremental_reachability_test.cc
@@ -16,7 +16,7 @@ TEST_SUITE("Decremental Reachability Test") {
     //       2 --> 3 --> 1
     //             3 --> 5
     //             3 --> 9
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 4);
     G.insert(2, 3);
@@ -35,32 +35,32 @@ TEST_SUITE("Decremental Reachability Test") {
 
     REQUIRE_EQ(G.V(), 9);
 
-    algo::RodittyZwick<std::uint16_t> rodittyZwick(G);
-    rodittyZwick.init();
+    auto rz = std::make_unique<algo::RodittyZwick<int>>(G);
+    rz->init();
     
     SUBCASE("RodittyZwick::query") {
-      CHECK_EQ(rodittyZwick.query(1, 2), true);
-      CHECK_EQ(rodittyZwick.query(1, 4), false);
-      CHECK_EQ(rodittyZwick.query(3, 9), false);
+      CHECK_EQ(rz->query(1, 2), true);
+      CHECK_EQ(rz->query(1, 4), false);
+      CHECK_EQ(rz->query(3, 9), false);
     }
 
     SUBCASE("RodittyZwick::remove") {
-      rodittyZwick.remove(7, 8);
+      rz->remove(7, 8);
 
-      CHECK_EQ(rodittyZwick.query(7, 8), true);
-      CHECK_EQ(rodittyZwick.query(4, 8), false);
+      CHECK_EQ(rz->query(7, 8), true);
+      CHECK_EQ(rz->query(4, 8), false);
 
-      rodittyZwick.remove(6, 8);
+      rz->remove(6, 8);
 
-      CHECK_EQ(rodittyZwick.query(5, 7), true);
-      CHECK_EQ(rodittyZwick.query(6, 8), false);
-      CHECK_EQ(rodittyZwick.query(5, 6), false);
+      CHECK_EQ(rz->query(5, 7), true);
+      CHECK_EQ(rz->query(6, 8), false);
+      CHECK_EQ(rz->query(5, 6), false);
 
-      rodittyZwick.remove(3, 1);
+      rz->remove(3, 1);
 
-      CHECK_EQ(rodittyZwick.query(1, 2), false);
-      CHECK_EQ(rodittyZwick.query(1, 3), false);
-      CHECK_EQ(rodittyZwick.query(2, 3), false);
+      CHECK_EQ(rz->query(1, 2), false);
+      CHECK_EQ(rz->query(1, 3), false);
+      CHECK_EQ(rz->query(2, 3), false);
     }
   }
 
@@ -70,7 +70,7 @@ TEST_SUITE("Decremental Reachability Test") {
     //                         7 --> 9
     // 1 --> 3 --> 9
     //       3 --> 5 --> 6
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(1, 3);
     G.insert(2, 4);
@@ -87,33 +87,33 @@ TEST_SUITE("Decremental Reachability Test") {
 
     REQUIRE_EQ(G.V(), 9);
 
-    algo::Italiano<std::uint16_t> italiano(G);
-    italiano.init();
+    auto italiano = std::make_unique<algo::Italiano<int>>(G);
+    italiano->init();
 
     SUBCASE("Italiano::query") {
-      CHECK_EQ(italiano.query(1, 9), true);
-      CHECK_EQ(italiano.query(2, 8), true);
-      CHECK_EQ(italiano.query(3, 7), true);
-      CHECK_EQ(italiano.query(4, 3), false);
-      CHECK_EQ(italiano.query(5, 4), false);
-      CHECK_EQ(italiano.query(6, 1), false);
+      CHECK_EQ(italiano->query(1, 9), true);
+      CHECK_EQ(italiano->query(2, 8), true);
+      CHECK_EQ(italiano->query(3, 7), true);
+      CHECK_EQ(italiano->query(4, 3), false);
+      CHECK_EQ(italiano->query(5, 4), false);
+      CHECK_EQ(italiano->query(6, 1), false);
     }
 
     SUBCASE("Italiano::remove") {
-      italiano.remove(4, 6);
+      italiano->remove(4, 6);
 
-      CHECK_EQ(italiano.query(3, 6), true);
-      CHECK_EQ(italiano.query(4, 6), true);
+      CHECK_EQ(italiano->query(3, 6), true);
+      CHECK_EQ(italiano->query(4, 6), true);
 
-      italiano.remove(5, 6);
+      italiano->remove(5, 6);
 
-      CHECK_EQ(italiano.query(1, 9), true);
-      CHECK_EQ(italiano.query(1, 6), false);
+      CHECK_EQ(italiano->query(1, 9), true);
+      CHECK_EQ(italiano->query(1, 6), false);
 
-      italiano.remove(1, 2);
+      italiano->remove(1, 2);
 
-      CHECK_EQ(italiano.query(1, 5), true);
-      CHECK_EQ(italiano.query(1, 2), false);
+      CHECK_EQ(italiano->query(1, 5), true);
+      CHECK_EQ(italiano->query(1, 2), false);
     }
   }
 
@@ -125,7 +125,7 @@ TEST_SUITE("Decremental Reachability Test") {
     //       2 --> 3 --> 1
     //             3 --> 5
     //             3 --> 9
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 4);
     G.insert(2, 3);
@@ -144,36 +144,36 @@ TEST_SUITE("Decremental Reachability Test") {
 
     REQUIRE_EQ(G.V(), 9);
 
-    algo::Frigioni<std::uint16_t> frigioni(G);
-    frigioni.init();
+    auto frigioni = std::make_unique<algo::Frigioni<int>>(G);
+    frigioni->init();
     
     SUBCASE("Frigioni::query") {
-      CHECK_EQ(frigioni.query(1, 9), true);
-      CHECK_EQ(frigioni.query(2, 8), true);
-      CHECK_EQ(frigioni.query(3, 9), true);
-      CHECK_EQ(frigioni.query(9, 5), true);
-      CHECK_EQ(frigioni.query(4, 3), false);
-      CHECK_EQ(frigioni.query(5, 4), false);
-      CHECK_EQ(frigioni.query(6, 1), false);
+      CHECK_EQ(frigioni->query(1, 9), true);
+      CHECK_EQ(frigioni->query(2, 8), true);
+      CHECK_EQ(frigioni->query(3, 9), true);
+      CHECK_EQ(frigioni->query(9, 5), true);
+      CHECK_EQ(frigioni->query(4, 3), false);
+      CHECK_EQ(frigioni->query(5, 4), false);
+      CHECK_EQ(frigioni->query(6, 1), false);
     }
     
     SUBCASE("Frigioni::remove") {
-      frigioni.remove({ {7, 8}, {6, 8}, {3, 1} });
+      frigioni->remove({ {7, 8}, {6, 8}, {3, 1} });
 
-      CHECK_EQ(frigioni.query(1, 3), true);
-      CHECK_EQ(frigioni.query(1, 9), true);
-      CHECK_EQ(frigioni.query(4, 5), true);
-      CHECK_EQ(frigioni.query(3, 1), false);
-      CHECK_EQ(frigioni.query(6, 8), false);
-      CHECK_EQ(frigioni.query(7, 8), false);
-      CHECK_EQ(frigioni.query(1, 8), false);
-      CHECK_EQ(frigioni.query(8, 4), false);
+      CHECK_EQ(frigioni->query(1, 3), true);
+      CHECK_EQ(frigioni->query(1, 9), true);
+      CHECK_EQ(frigioni->query(4, 5), true);
+      CHECK_EQ(frigioni->query(3, 1), false);
+      CHECK_EQ(frigioni->query(6, 8), false);
+      CHECK_EQ(frigioni->query(7, 8), false);
+      CHECK_EQ(frigioni->query(1, 8), false);
+      CHECK_EQ(frigioni->query(8, 4), false);
 
-      frigioni.remove({ {4, 5}, {5, 6} });
+      frigioni->remove({ {4, 5}, {5, 6} });
 
-      CHECK_EQ(frigioni.query(2, 9), true);
-      CHECK_EQ(frigioni.query(9, 6), false);
-      CHECK_EQ(frigioni.query(4, 6), false);
+      CHECK_EQ(frigioni->query(2, 9), true);
+      CHECK_EQ(frigioni->query(9, 6), false);
+      CHECK_EQ(frigioni->query(4, 6), false);
     }
   }
 }
\ No newline at end of file
diff --git a/test/dynamic_reachability_test.cc b/test/dynamic_reachability_test.cc
index 6b3020e..d045619 100644
--- a/test/dynamic_reachability_test.cc
+++ b/test/dynamic_reachability_test.cc
@@ -13,7 +13,7 @@ TEST_SUITE("Dynamic Reachability Test") {
     //                         7 --> 9
     // 1 --> 3 --> 9
     //       3 --> 5 --> 6
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(1, 3);
     G.insert(2, 4);
@@ -30,7 +30,7 @@ TEST_SUITE("Dynamic Reachability Test") {
 
     REQUIRE_EQ(G.V(), 9);
 
-    algo::King<std::uint16_t> king(G);
+    auto king = algo::King<int>(G);
     king.init();
 
     SUBCASE("King::query") {
@@ -75,7 +75,7 @@ TEST_SUITE("Dynamic Reachability Test") {
     //       2 --> 3 --> 1
     //             3 --> 5
     //             3 --> 9
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 4);
     G.insert(2, 3);
@@ -94,46 +94,46 @@ TEST_SUITE("Dynamic Reachability Test") {
 
     REQUIRE_EQ(G.V(), 9);
 
-    algo::HenzingerKing<std::uint16_t> henzingerKing(G);
-    henzingerKing.init();
+    auto hk = std::make_unique<algo::HenzingerKing<int>>(G);
+    hk->init();
     
     SUBCASE("HenzingerKing::query") {
-      CHECK_EQ(henzingerKing.query(1, 9), true);
-      CHECK_EQ(henzingerKing.query(2, 8), true);
-      CHECK_EQ(henzingerKing.query(3, 9), true);
-      CHECK_EQ(henzingerKing.query(9, 5), true);
-      CHECK_EQ(henzingerKing.query(4, 3), false);
-      CHECK_EQ(henzingerKing.query(5, 4), false);
-      CHECK_EQ(henzingerKing.query(6, 1), false);
+      CHECK_EQ(hk->query(1, 9), true);
+      CHECK_EQ(hk->query(2, 8), true);
+      CHECK_EQ(hk->query(3, 9), true);
+      CHECK_EQ(hk->query(9, 5), true);
+      CHECK_EQ(hk->query(4, 3), false);
+      CHECK_EQ(hk->query(5, 4), false);
+      CHECK_EQ(hk->query(6, 1), false);
     }
 
     SUBCASE("HenzingerKing::remove") {
-      henzingerKing.remove({ {7, 8}, {6, 8}, {3, 1} });
+      hk->remove({ {7, 8}, {6, 8}, {3, 1} });
 
-      CHECK_EQ(henzingerKing.query(1, 3), true);
-      CHECK_EQ(henzingerKing.query(1, 9), true);
-      CHECK_EQ(henzingerKing.query(4, 5), true);
-      CHECK_EQ(henzingerKing.query(3, 1), false);
-      CHECK_EQ(henzingerKing.query(6, 8), false);
-      CHECK_EQ(henzingerKing.query(7, 8), false);
-      CHECK_EQ(henzingerKing.query(1, 8), false);
-      CHECK_EQ(henzingerKing.query(8, 4), false);
+      CHECK_EQ(hk->query(1, 3), true);
+      CHECK_EQ(hk->query(1, 9), true);
+      CHECK_EQ(hk->query(4, 5), true);
+      CHECK_EQ(hk->query(3, 1), false);
+      CHECK_EQ(hk->query(6, 8), false);
+      CHECK_EQ(hk->query(7, 8), false);
+      CHECK_EQ(hk->query(1, 8), false);
+      CHECK_EQ(hk->query(8, 4), false);
 
-      henzingerKing.remove({ {4, 5}, {5, 6} });
+      hk->remove({ {4, 5}, {5, 6} });
 
-      CHECK_EQ(henzingerKing.query(2, 9), true);
-      CHECK_EQ(henzingerKing.query(9, 6), false);
-      CHECK_EQ(henzingerKing.query(4, 6), false);
+      CHECK_EQ(hk->query(2, 9), true);
+      CHECK_EQ(hk->query(9, 6), false);
+      CHECK_EQ(hk->query(4, 6), false);
     }
 
     SUBCASE("HenzingerKing::insert") {
-      henzingerKing.insert(9, { { 1, 10 } });
+      hk->insert(9, { { 1, 10 } });
 
-      CHECK_EQ(henzingerKing.query(1, 9), true);
-      CHECK_EQ(henzingerKing.query(9, 1), true);
+      CHECK_EQ(hk->query(1, 9), true);
+      CHECK_EQ(hk->query(9, 1), true);
 
-      CHECK_EQ(henzingerKing.query(1, 10), true);
-      CHECK_EQ(henzingerKing.query(10, 1), false);
+      CHECK_EQ(hk->query(1, 10), true);
+      CHECK_EQ(hk->query(10, 1), false);
     }
   }
 }
\ No newline at end of file
diff --git a/test/graph_test.cc b/test/graph_test.cc
index f0a421a..3b310a7 100644
--- a/test/graph_test.cc
+++ b/test/graph_test.cc
@@ -15,7 +15,7 @@ TEST_SUITE("Graph") {
     //                   7 --> 9
     //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
     //                                       12 --> 10
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 3);
     G.insert(3, 1);
@@ -39,8 +39,8 @@ TEST_SUITE("Graph") {
 
     auto reverse = G.reverse();
 
-    std::unordered_map<std::uint16_t,
-      std::unordered_set<std::uint16_t>> expected = {
+    std::unordered_map<int,
+      std::unordered_set<int>> expected = {
       {1, {3}},
       {2, {1}},
       {3, {2, 5}},
@@ -66,7 +66,7 @@ TEST_SUITE("Graph") {
     //                   7 --> 9
     //             6 --> 9 --> 10 --> 11 --> 12 --> 13 --> 9
     //                                       12 --> 10
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 3);
     G.insert(3, 1);
@@ -98,7 +98,7 @@ TEST_SUITE("Graph") {
     //       2 --> 3 --> 1
     //             3 --> 5
     //             3 --> 9
-    Digraph<std::uint16_t> G;
+    Digraph<int> G;
     G.insert(1, 2);
     G.insert(2, 4);
     G.insert(2, 3);
@@ -117,9 +117,9 @@ TEST_SUITE("Graph") {
 
     REQUIRE_EQ(G.V(), 9);
 
-    auto SCCs = algo::Tarjan<std::uint16_t>(G.adjList).execute();
+    auto SCCs = algo::Tarjan<int>(G.adjList).execute();
     
-    std::vector<std::vector<std::uint16_t>> expected = {
+    std::vector<std::vector<int>> expected = {
       {5, 6, 7, 8, 9},
       {4},
       {1, 2, 3}