diff --git a/include/rotgen/functions/functions.hpp b/include/rotgen/functions/functions.hpp
index c727959..c48cb59 100644
--- a/include/rotgen/functions/functions.hpp
+++ b/include/rotgen/functions/functions.hpp
@@ -218,17 +218,20 @@ namespace rotgen
   //-----------------------------------------------------------------------------------------------
   // Reductions
   //-----------------------------------------------------------------------------------------------
-  auto trace(concepts::entity auto const& arg)
+  auto trace(auto const& arg)
+  requires requires { arg.trace(); }
   {
     return arg.trace();
   }
 
-  auto squaredNorm(concepts::entity auto const& arg)
+  auto squaredNorm(auto const& arg)
+  requires requires { arg.squaredNorm(); }
   {
     return arg.squaredNorm();
   }
 
-  auto norm(concepts::entity auto const& arg)
+  auto norm(auto const& arg)
+  requires requires { arg.norm(); }
   {
     return arg.norm();
   }
@@ -239,12 +242,14 @@ namespace rotgen
     return arg.sum();
   }
 
-  auto prod(concepts::entity auto const& arg)
+  auto prod(auto const& arg)
+  requires requires { arg.prod(); }
   {
     return arg.prod();
   }
 
-  auto mean(concepts::entity auto const& arg)
+  auto mean(auto const& arg)
+  requires requires { arg.mean(); }
   {
     return arg.mean();
   }
@@ -272,17 +277,15 @@ namespace rotgen
   }
 
   template<std::integral IndexType>
-  auto maxCoeff(concepts::entity auto const& arg,
-                IndexType* row,
-                IndexType* col)
+  auto maxCoeff(auto const& arg, IndexType* row, IndexType* col)
+  requires(requires { arg.maxCoeff(row, col); })
   {
     return arg.maxCoeff(row, col);
   }
 
   template<std::integral IndexType>
-  auto minCoeff(concepts::entity auto const& arg,
-                IndexType* row,
-                IndexType* col)
+  auto minCoeff(auto const& arg, IndexType* row, IndexType* col)
+  requires(requires { arg.minCoeff(row, col); })
   {
     return arg.minCoeff(row, col);
   }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2a245c7..3ae846d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -14,6 +14,11 @@ target_compile_options(rotgen_test INTERFACE -std=c++20 -Werror -Wall -Wextra -W
 target_include_directories( rotgen_test INTERFACE ${PROJECT_SOURCE_DIR}/test)
 target_link_libraries(rotgen_test INTERFACE rotgen Eigen3::Eigen)
 
+target_compile_definitions(rotgen_test INTERFACE
+  TTS_MAIN
+  TTS_CUSTOM_DRIVER_FUNCTION=rotgen_main
+)
+
 ##======================================================================================================================
 ## Unit Tests registration
 ##======================================================================================================================
diff --git a/test/unit/block/generators.cpp b/test/unit/block/generators.cpp
index 6a658ea..786d55d 100644
--- a/test/unit/block/generators.cpp
+++ b/test/unit/block/generators.cpp
@@ -5,9 +5,11 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
-#include "unit/tests.hpp"
 #include <rotgen/rotgen.hpp>
 
+#include "rotgen/functions/functions.hpp"
+#include "unit/tests.hpp"
+
 void test_value(auto const& matrix,
                 auto value,
                 rotgen::Index i0,
@@ -57,7 +59,7 @@ TTS_CASE_TPL("Test dynamic block::setZero",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract(m, i0, j0, ni, nj);
 
-    input.setZero();
+    rotgen::setZero(input);
     test_value(m, T{0}, i0, j0, ni, nj);
 
     using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@@ -66,7 +68,7 @@ TTS_CASE_TPL("Test dynamic block::setZero",
   }
 };
 
-TTS_CASE_TPL("Test static block:setZero",
+TTS_CASE_TPL("Test static block::setZero",
              rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
@@ -80,7 +82,7 @@ TTS_CASE_TPL("Test static block:setZero",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
 
-    input.setZero();
+    rotgen::setZero(input);
     test_value(m, T{0}, i0, j0, D::ni, D::nj);
 
     using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@@ -103,7 +105,7 @@ TTS_CASE_TPL("Test dynamic block::setOnes",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract(m, i0, j0, ni, nj);
 
-    input.setOnes();
+    rotgen::setOnes(input);
     test_value(m, T{1}, i0, j0, ni, nj);
 
     using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@@ -112,7 +114,7 @@ TTS_CASE_TPL("Test dynamic block::setOnes",
   }
 };
 
-TTS_CASE_TPL("Test static block:setOnes",
+TTS_CASE_TPL("Test static block::setOnes",
              rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
@@ -126,7 +128,7 @@ TTS_CASE_TPL("Test static block:setOnes",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
 
-    input.setOnes();
+    rotgen::setOnes(input);
     test_value(m, T{1}, i0, j0, D::ni, D::nj);
 
     using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@@ -149,7 +151,7 @@ TTS_CASE_TPL("Test dynamic block::setConstant",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract(m, i0, j0, ni, nj);
 
-    input.setConstant(T{13.37f});
+    rotgen::setConstant(input, T{13.37f});
     test_value(m, T{13.37f}, i0, j0, ni, nj);
 
     using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@@ -158,7 +160,7 @@ TTS_CASE_TPL("Test dynamic block::setConstant",
   }
 };
 
-TTS_CASE_TPL("Test static block:setConstant",
+TTS_CASE_TPL("Test static block::setConstant",
              rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
@@ -172,7 +174,7 @@ TTS_CASE_TPL("Test static block:setConstant",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
 
-    input.setConstant(T{13.37f});
+    rotgen::setConstant(input, T{13.37f});
     test_value(m, T{13.37f}, i0, j0, D::ni, D::nj);
 
     using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@@ -195,7 +197,7 @@ TTS_CASE_TPL("Test dynamic block::setIdentity",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract(m, i0, j0, ni, nj);
 
-    input.setIdentity();
+    rotgen::setIdentity(input);
     test_identity(m, i0, j0, ni, nj);
 
     using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@@ -204,7 +206,7 @@ TTS_CASE_TPL("Test dynamic block::setIdentity",
   }
 };
 
-TTS_CASE_TPL("Test static block:setIdentity",
+TTS_CASE_TPL("Test static block::setIdentity",
              rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
@@ -218,7 +220,7 @@ TTS_CASE_TPL("Test static block:setIdentity",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
 
-    input.setIdentity();
+    rotgen::setIdentity(input);
     test_identity(m, i0, j0, D::ni, D::nj);
 
     using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
@@ -241,7 +243,7 @@ TTS_CASE_TPL("Test dynamic block::setRandom",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract(m, i0, j0, ni, nj);
 
-    input.setRandom();
+    rotgen::setRandom(input);
     test_random(m, i0, j0, ni, nj);
 
     using input_type = decltype(rotgen::extract(m, i0, j0, ni, nj));
@@ -250,7 +252,7 @@ TTS_CASE_TPL("Test dynamic block::setRandom",
   }
 };
 
-TTS_CASE_TPL("Test static block:setRandom",
+TTS_CASE_TPL("Test static block::setRandom",
              rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
@@ -264,7 +266,7 @@ TTS_CASE_TPL("Test static block:setRandom",
     rotgen::tests::prepare(rows, cols, fn, m);
     auto input = rotgen::extract<D::ni, D::nj>(m, i0, j0);
 
-    input.setRandom();
+    rotgen::setRandom(input);
     test_random(m, i0, j0, D::ni, D::nj);
 
     using input_type = decltype(rotgen::extract<D::ni, D::nj>(m, i0, j0));
diff --git a/test/unit/common/arithmetic.hpp b/test/unit/common/arithmetic.hpp
index 7c6e41b..c102294 100644
--- a/test/unit/common/arithmetic.hpp
+++ b/test/unit/common/arithmetic.hpp
@@ -5,81 +5,85 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
+#pragma once
+
 #include <rotgen/rotgen.hpp>
+
+#include "tts.hpp"
 #include <Eigen/Dense>
-#include <vector>
-#include <tuple>
 
 namespace rotgen::tests
 {
-  template<typename T> void check_shape_functions(T original)
+  template<typename T> void check_shape_functions(T rotgen_input)
   {
-    using mat_t =
+    using eigen_mat_t =
       matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
 
-    mat_t result(original.cols(), original.rows());
-    prepare([&](auto r, auto c) { return original(c, r); }, result);
+    eigen_mat_t eigen_result(rotgen_input.cols(), rotgen_input.rows());
+    prepare([&](auto r, auto c) { return rotgen_input(c, r); }, eigen_result);
 
-    TTS_EQUAL(transpose(original), result);
-    TTS_EQUAL(conjugate(original), original);
-    TTS_EQUAL(adjoint(original), result);
+    TTS_EQUAL(transpose(rotgen_input), eigen_result);
+    TTS_EQUAL(conjugate(rotgen_input), rotgen_input);
+    TTS_EQUAL(adjoint(rotgen_input), eigen_result);
 
     if constexpr (T::is_defined_static)
     {
       if constexpr (T::RowsAtCompileTime == T::ColsAtCompileTime)
       {
-        mat_t ref = original;
-        transposeInPlace(original);
-        TTS_EQUAL(original, result);
+        eigen_mat_t ref = rotgen_input;
+        transposeInPlace(rotgen_input);
+        TTS_EQUAL(rotgen_input, eigen_result);
 
-        adjointInPlace(original);
-        TTS_EQUAL(original, ref);
+        adjointInPlace(rotgen_input);
+        TTS_EQUAL(rotgen_input, ref);
       }
     }
     else
     {
-      if (original.rows() == original.cols())
+      if (rotgen_input.rows() == rotgen_input.cols())
       {
-        mat_t ref = original;
-        transposeInPlace(original);
-        TTS_EQUAL(original, result);
+        eigen_mat_t eigen_ref = rotgen_input;
+        transposeInPlace(rotgen_input);
+        TTS_EQUAL(rotgen_input, eigen_result);
 
-        adjointInPlace(original);
-        TTS_EQUAL(original, ref);
+        adjointInPlace(rotgen_input);
+        TTS_EQUAL(rotgen_input, eigen_ref);
       }
     }
 
     if constexpr (!rotgen::use_expression_templates)
     {
-      TTS_EXPECT(verify_rotgen_reentrance(original.transpose()));
-      TTS_EXPECT(verify_rotgen_reentrance(original.conjugate()));
-      TTS_EXPECT(verify_rotgen_reentrance(original.adjoint()));
+      TTS_EXPECT(verify_rotgen_reentrance(transpose(rotgen_input)));
+      TTS_EXPECT(verify_rotgen_reentrance(conjugate(rotgen_input)));
+      TTS_EXPECT(verify_rotgen_reentrance(adjoint(rotgen_input)));
     }
   }
 
-  template<typename T> void check_reduction_functions(T const& input)
+  template<typename T> void check_reduction_functions(T const& rotgen_input)
   {
-    using EigenMatrix =
+    using eigen_mat_t =
       Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
 
-    EigenMatrix ref(input.rows(), input.cols());
-    prepare([&](auto r, auto c) { return input(r, c); }, ref);
+    eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
+    prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
 
-    TTS_ULP_EQUAL(sum(input), ref.sum(), 2);
-    TTS_ULP_EQUAL(prod(input), ref.prod(), 2);
-    TTS_ULP_EQUAL(mean(input), ref.mean(), 2);
-    TTS_EQUAL(trace(input), ref.trace());
-    TTS_EQUAL(minCoeff(input), ref.minCoeff());
-    TTS_EQUAL(maxCoeff(input), ref.maxCoeff());
+    TTS_ULP_EQUAL(sum(rotgen_input), eigen_ref.sum(), 2);
+    TTS_ULP_EQUAL(prod(rotgen_input), eigen_ref.prod(), 2);
+    TTS_ULP_EQUAL(mean(rotgen_input), eigen_ref.mean(), 2);
+    TTS_EQUAL(trace(rotgen_input), eigen_ref.trace());
+    TTS_EQUAL(minCoeff(rotgen_input), eigen_ref.minCoeff());
+    TTS_EQUAL(maxCoeff(rotgen_input), eigen_ref.maxCoeff());
 
     {
       int row, col, ref_row, ref_col;
 
-      TTS_EQUAL(minCoeff(input, &row, &col), ref.minCoeff(&ref_row, &ref_col));
+      TTS_EQUAL(minCoeff(rotgen_input, &row, &col),
+                eigen_ref.minCoeff(&ref_row, &ref_col));
       TTS_EQUAL(row, ref_row);
       TTS_EQUAL(col, ref_col);
 
-      TTS_EQUAL(maxCoeff(input, &row, &col), ref.maxCoeff(&ref_row, &ref_col));
+      TTS_EQUAL(maxCoeff(rotgen_input, &row, &col),
+                eigen_ref.maxCoeff(&ref_row, &ref_col));
       TTS_EQUAL(row, ref_row);
       TTS_EQUAL(col, ref_col);
     }
diff --git a/test/unit/common/cwise.hpp b/test/unit/common/cwise.hpp
index f34badb..9e903b1 100644
--- a/test/unit/common/cwise.hpp
+++ b/test/unit/common/cwise.hpp
@@ -5,89 +5,60 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
+#pragma once
+
 #include <rotgen/rotgen.hpp>
+
+#include "tts.hpp"
 #include <Eigen/Dense>
-#include <vector>
-#include <tuple>
 
 namespace rotgen::tests
 {
-  template<typename T> void check_cwise_functions(T const& input)
+  template<typename T> void check_cwise_functions(T const& rotgen_input)
   {
-    using EigenMatrix =
+    using eigen_mat_t =
       Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
-    using mat_t =
+
+    using rotgen_mat_t =
       matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;
 
     TTS_WHEN("Unary Cwise operations")
     {
-      EigenMatrix e_ref(input.rows(), input.cols());
-      prepare([&](auto r, auto c) { return input(r, c); }, e_ref);
+      eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
+      prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);
 
-      mat_t ref(input.rows(), input.cols());
-
-      TTS_AND_THEN(".cwiseAbs")
-      {
-        e_ref = e_ref.cwiseAbs();
-        prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
-        TTS_EQUAL(input.cwiseAbs(), ref);
-      }
-
-      TTS_AND_THEN(".cwiseAbs2")
-      {
-        e_ref = e_ref.cwiseAbs2();
-        prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
-        TTS_EQUAL(input.cwiseAbs2(), ref);
-      }
-
-      TTS_AND_THEN(".cwiseInverse")
-      {
-        e_ref = e_ref.cwiseInverse();
-        prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
-        TTS_EQUAL(input.cwiseInverse(), ref);
-      }
-
-      TTS_AND_THEN(".cwiseSqrt")
-      {
-        e_ref = e_ref.cwiseAbs().cwiseSqrt();
-        auto mat = input.cwiseAbs();
-        auto proper_input = mat.cwiseSqrt();
-
-        for (rotgen::Index r = 0; r < input.rows(); ++r)
-          for (rotgen::Index c = 0; c < input.cols(); ++c)
-            TTS_ULP_EQUAL(proper_input(r, c), e_ref(r, c), 1);
-      }
+      rotgen_mat_t rotgen_ref(rotgen_input.rows(), rotgen_input.cols());
 
       TTS_AND_THEN("abs()")
       {
-        e_ref = e_ref.cwiseAbs();
-        prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
-        TTS_EQUAL(rotgen::abs(input), ref);
+        eigen_ref = eigen_ref.cwiseAbs();
+        prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
+        TTS_EQUAL(rotgen::abs(rotgen_input), rotgen_ref);
       }
 
       TTS_AND_THEN("abs2()")
       {
-        e_ref = e_ref.cwiseAbs2();
-        prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
-        TTS_EQUAL(rotgen::abs2(input), ref);
+        eigen_ref = eigen_ref.cwiseAbs2();
+        prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
+        TTS_EQUAL(rotgen::abs2(rotgen_input), rotgen_ref);
       }
 
       TTS_AND_THEN("rec")
       {
-        e_ref = e_ref.cwiseInverse();
-        prepare([&](auto r, auto c) { return e_ref(r, c); }, ref);
-        TTS_EQUAL(rotgen::rec(input), ref);
+        eigen_ref = eigen_ref.cwiseInverse();
+        prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
+        TTS_EQUAL(rotgen::rec(rotgen_input), rotgen_ref);
       }
 
       TTS_AND_THEN("sqrt")
       {
-        e_ref = e_ref.cwiseAbs().cwiseSqrt();
-        auto mat = input.cwiseAbs();
+        eigen_ref = eigen_ref.cwiseAbs().cwiseSqrt();
+        auto mat = rotgen::abs(rotgen_input);
         auto proper_input = rotgen::sqrt(mat);
 
-        for (rotgen::Index r = 0; r < input.rows(); ++r)
-          for (rotgen::Index c = 0; c < input.cols(); ++c)
-            TTS_ULP_EQUAL(proper_input(r, c), e_ref(r, c), 1);
+        for (rotgen::Index r = 0; r < rotgen_input.rows(); ++r)
+          for (rotgen::Index c = 0; c < rotgen_input.cols(); ++c)
+            TTS_ULP_EQUAL(proper_input(r, c), eigen_ref(r, c), 1);
       }
     }
   }
diff --git a/test/unit/common/norms.hpp b/test/unit/common/norms.hpp
index 661e38f..9c6fca8 100644
--- a/test/unit/common/norms.hpp
+++ b/test/unit/common/norms.hpp
@@ -5,42 +5,47 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
+#pragma once
+
 #include <rotgen/rotgen.hpp>
+
+#include "tts.hpp"
 #include <Eigen/Dense>
-#include <vector>
-#include <tuple>
 
 namespace rotgen::tests
 {
-  template<typename T> void check_norms_functions(T const& input)
+  template<typename T> void check_norms_functions(T const& rotgen_input)
   {
-    using EigenMatrix =
+    using eigen_mat_t =
       Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;
 
-    EigenMatrix ref(input.rows(), input.cols());
+    eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
 
-    prepare([&](auto r, auto c) { return input(r, c); }, ref);
+    prepare([&](auto row, auto col) { return rotgen_input(row, col); },
+            eigen_ref);
 
-    TTS_EQUAL(rotgen::norm(input), ref.norm());
-    TTS_EQUAL(rotgen::squaredNorm(input), ref.squaredNorm());
-    TTS_EQUAL(rotgen::lpNorm<1>(input), ref.template lpNorm<1>());
-    TTS_EQUAL(rotgen::lpNorm<2>(input), ref.template lpNorm<2>());
-    TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(input),
-              ref.template lpNorm<Eigen::Infinity>());
+    TTS_EQUAL(rotgen::norm(rotgen_input), eigen_ref.norm());
+    TTS_EQUAL(rotgen::squaredNorm(rotgen_input), eigen_ref.squaredNorm());
+    TTS_EQUAL(rotgen::lpNorm<1>(rotgen_input), eigen_ref.template lpNorm<1>());
+    TTS_EQUAL(rotgen::lpNorm<2>(rotgen_input), eigen_ref.template lpNorm<2>());
+    TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(rotgen_input),
+              eigen_ref.template lpNorm<Eigen::Infinity>());
 
     if constexpr (T::IsVectorAtCompileTime)
     {
-      EigenMatrix e_norm = ref.normalized();
-      using mat_t = rotgen::matrix<typename T::value_type, rotgen::Dynamic,
-                                   rotgen::Dynamic, T::storage_order>;
-      mat_t norm_ref(input.rows(), input.cols());
-      prepare([&](auto r, auto c) { return e_norm(r, c); }, norm_ref);
+      eigen_mat_t eigen_normalized = eigen_ref.normalized();
+      using rotgen_mat_t =
+        rotgen::matrix<typename T::value_type, rotgen::Dynamic, rotgen::Dynamic,
+                       T::storage_order>;
+      rotgen_mat_t rotgen_norm_ref(rotgen_input.rows(), rotgen_input.cols());
+      prepare([&](auto row, auto col) { return eigen_normalized(row, col); },
+              rotgen_norm_ref);
 
-      TTS_EQUAL(rotgen::normalized(input), norm_ref);
+      TTS_EQUAL(rotgen::normalized(rotgen_input), rotgen_norm_ref);
 
-      auto f_norm = input;
-      rotgen::normalize(f_norm);
-      TTS_EQUAL(f_norm, norm_ref);
+      auto rotgen_f_norm = rotgen_input;
+      rotgen::normalize(rotgen_f_norm);
+      TTS_EQUAL(rotgen_f_norm, rotgen_norm_ref);
     }
   }
 }
diff --git a/test/unit/common/references.hpp b/test/unit/common/references.hpp
index 3aa662c..97c2bd3 100644
--- a/test/unit/common/references.hpp
+++ b/test/unit/common/references.hpp
@@ -5,11 +5,13 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
+#pragma once
 
 #include <rotgen/rotgen.hpp>
+
 #include <Eigen/Dense>
-#include <vector>
 #include <tuple>
+#include <vector>
 
 namespace rotgen::tests
 {
diff --git a/test/unit/functions/rowwise.cpp b/test/unit/functions/rowwise.cpp
index bc7f0ba..8afdce1 100644
--- a/test/unit/functions/rowwise.cpp
+++ b/test/unit/functions/rowwise.cpp
@@ -5,61 +5,68 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
-#include "unit/tests.hpp"
 #include <rotgen/rotgen.hpp>
 
+#include "unit/tests.hpp"
+
 TTS_CASE_TPL("rowwise API", rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
-  using e_t = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
-  e_t ref = e_t::Random(4, 4);
-  auto ref_rw = ref.rowwise();
+  using eigen_mat_t =
+    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
+  eigen_mat_t eigen_ref = eigen_mat_t::Random(4, 4);
+  auto eigen_ref_rw = eigen_ref.rowwise();
 
-  rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> mat(4, 4);
-  rotgen::tests::prepare([&](auto r, auto c) { return ref(r, c); }, mat);
+  rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> rotgen_mat(4,
+                                                                           4);
+  rotgen::tests::prepare([&](auto r, auto c) { return eigen_ref(r, c); },
+                         rotgen_mat);
 
-  auto rw = rotgen::rowwise(mat);
+  auto rotgen_rw = rotgen::rowwise(rotgen_mat);
 
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.sum()(i), ref_rw.sum()(i));
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.mean()(i), ref_rw.mean()(i));
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.prod()(i), ref_rw.prod()(i));
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.maxCoeff()(i), ref_rw.maxCoeff()(i));
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.minCoeff()(i), ref_rw.minCoeff()(i));
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.squaredNorm()(i), ref_rw.squaredNorm()(i));
-  for (rotgen::Index i = 0; i < mat.rows(); ++i)
-    TTS_EQUAL(rw.norm()(i), ref_rw.norm()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::sum(rotgen_rw)(i), eigen_ref_rw.sum()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::mean(rotgen_rw)(i), eigen_ref_rw.mean()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::prod(rotgen_rw)(i), eigen_ref_rw.prod()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::maxCoeff(rotgen_rw)(i), eigen_ref_rw.maxCoeff()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::minCoeff(rotgen_rw)(i), eigen_ref_rw.minCoeff()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::squaredNorm(rotgen_rw)(i), eigen_ref_rw.squaredNorm()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.rows(); ++i)
+    TTS_EQUAL(rotgen::norm(rotgen_rw)(i), eigen_ref_rw.norm()(i));
 };
 
 TTS_CASE_TPL("colwise API", rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
 {
-  using e_t = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
-  e_t ref = e_t::Random(4, 4);
-  auto ref_rw = ref.colwise();
+  using eigen_mat_t =
+    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, O::value>;
+  eigen_mat_t eigen_ref = eigen_mat_t::Random(4, 4);
+  auto eigen_ref_rw = eigen_ref.colwise();
 
-  rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> mat(4, 4);
-  rotgen::tests::prepare([&](auto r, auto c) { return ref(r, c); }, mat);
+  rotgen::matrix<T, rotgen::Dynamic, rotgen::Dynamic, O::value> rotgen_mat(4,
+                                                                           4);
+  rotgen::tests::prepare([&](auto r, auto c) { return eigen_ref(r, c); },
+                         rotgen_mat);
 
-  auto rw = rotgen::colwise(mat);
+  auto rotgen_rw = rotgen::colwise(rotgen_mat);
 
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.sum()(i), ref_rw.sum()(i));
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.mean()(i), ref_rw.mean()(i));
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.prod()(i), ref_rw.prod()(i));
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.maxCoeff()(i), ref_rw.maxCoeff()(i));
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.minCoeff()(i), ref_rw.minCoeff()(i));
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.squaredNorm()(i), ref_rw.squaredNorm()(i));
-  for (rotgen::Index i = 0; i < mat.cols(); ++i)
-    TTS_EQUAL(rw.norm()(i), ref_rw.norm()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::sum(rotgen_rw)(i), eigen_ref_rw.sum()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::mean(rotgen_rw)(i), eigen_ref_rw.mean()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::prod(rotgen_rw)(i), eigen_ref_rw.prod()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::maxCoeff(rotgen_rw)(i), eigen_ref_rw.maxCoeff()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::minCoeff(rotgen_rw)(i), eigen_ref_rw.minCoeff()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::squaredNorm(rotgen_rw)(i), eigen_ref_rw.squaredNorm()(i));
+  for (rotgen::Index i = 0; i < rotgen_mat.cols(); ++i)
+    TTS_EQUAL(rotgen::norm(rotgen_rw)(i), eigen_ref_rw.norm()(i));
 };
diff --git a/test/unit/matrix/basic_api.cpp b/test/unit/matrix/basic_api.cpp
index 72f5810..1b8656a 100644
--- a/test/unit/matrix/basic_api.cpp
+++ b/test/unit/matrix/basic_api.cpp
@@ -33,14 +33,14 @@ TTS_CASE_TPL("Resizing dynamic matrix",
   for (rotgen::Index r = 0; r < a.rows(); ++r)
     for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = 42 + 2 * c + r;
 
-  a.resize(3, 2);
+  rotgen::resize(a, 3, 2);
   TTS_EQUAL(a.rows(), rotgen::Index(3));
   TTS_EQUAL(a.cols(), rotgen::Index(2));
 
   for (rotgen::Index r = 0; r < a.rows(); ++r)
     for (rotgen::Index c = 0; c < a.cols(); ++c) TTS_GREATER(a(r, c), 0);
 
-  a.resize(2, 2);
+  rotgen::resize(a, 2, 2);
   TTS_EQUAL(a.rows(), rotgen::Index(2));
   TTS_EQUAL(a.cols(), rotgen::Index(2));
 };
@@ -55,7 +55,7 @@ TTS_CASE_TPL("Dynamix matrix conservative resizing",
   for (rotgen::Index r = 0; r < a.rows(); ++r)
     for (rotgen::Index c = 0; c < a.cols(); ++c) a(r, c) = i++;
 
-  a.conservativeResize(2, 3);
+  rotgen::conservativeResize(a, 2, 3);
   TTS_EQUAL(a.rows(), rotgen::Index(2));
   TTS_EQUAL(a.cols(), rotgen::Index(3));
 
@@ -63,36 +63,36 @@ TTS_CASE_TPL("Dynamix matrix conservative resizing",
   for (rotgen::Index r = 0; r < a.rows(); ++r)
     for (rotgen::Index c = 0; c < a.cols(); ++c) TTS_EQUAL(a(r, c), i++);
 
-  a.conservativeResize(3, 2);
+  rotgen::conservativeResize(a, 3, 2);
   TTS_EQUAL(a.rows(), rotgen::Index(3));
   TTS_EQUAL(a.cols(), rotgen::Index(2));
   int expected[3][2] = {{1, 2}, {4, 5}};
   for (rotgen::Index r = 0; r < 2; ++r)
     for (rotgen::Index c = 0; c < 2; ++c) TTS_EQUAL(a(r, c), expected[r][c]);
 
-  a.conservativeResize(4, 4);
+  rotgen::conservativeResize(a, 4, 4);
   TTS_EQUAL(a.rows(), rotgen::Index(4));
   TTS_EQUAL(a.cols(), rotgen::Index(4));
   TTS_EQUAL(a(0, 0), 1);
   TTS_EQUAL(a(3, 3), 0);
 
-  a.conservativeResize(2, 2);
+  rotgen::conservativeResize(a, 2, 2);
   TTS_EQUAL(a.rows(), rotgen::Index(2));
   TTS_EQUAL(a.cols(), rotgen::Index(2));
   TTS_EQUAL(a(0, 0), 1);
   TTS_EQUAL(a(1, 1), 5);
 
-  a.conservativeResize(1, 2);
+  rotgen::conservativeResize(a, 1, 2);
   TTS_EQUAL(a.rows(), rotgen::Index(1));
   TTS_EQUAL(a.cols(), rotgen::Index(2));
   TTS_EQUAL(a(0, 0), 1);
   TTS_EQUAL(a(0, 1), 2);
 
-  a.conservativeResize(0, 0);
+  rotgen::conservativeResize(a, 0, 0);
   TTS_EQUAL(a.rows(), rotgen::Index(0));
   TTS_EQUAL(a.cols(), rotgen::Index(0));
 
-  a.conservativeResize(3, 3);
+  rotgen::conservativeResize(a, 3, 3);
   TTS_EQUAL(a.rows(), rotgen::Index(3));
   TTS_EQUAL(a.cols(), rotgen::Index(3));
 };
diff --git a/test/unit/matrix/inverse.cpp b/test/unit/matrix/inverse.cpp
index 78f3800..adac60b 100644
--- a/test/unit/matrix/inverse.cpp
+++ b/test/unit/matrix/inverse.cpp
@@ -5,10 +5,11 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
-#include "unit/tests.hpp"
-#include "unit/common/arithmetic.hpp"
 #include <rotgen/rotgen.hpp>
 
+#include "unit/common/arithmetic.hpp"
+#include "unit/tests.hpp"
+
 TTS_CASE_TPL("Test dynamic matrix inverse",
              rotgen::tests::types)<typename T, typename O>(
   tts::type<tts::types<T, O>>)
diff --git a/test/unit/tests.hpp b/test/unit/tests.hpp
index c90c01d..4e45407 100644
--- a/test/unit/tests.hpp
+++ b/test/unit/tests.hpp
@@ -5,8 +5,8 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
-#define TTS_MAIN
-#define TTS_CUSTOM_DRIVER_FUNCTION rotgen_main
+#pragma once
+
 #include "tts.hpp"
 #include "unit/common/references.hpp"
 #include <rotgen/config.hpp>