diff --git a/CMakeLists.txt b/CMakeLists.txt
index 560dd74c04bf5f76dee000a9a8883276ff99bdfd..0676fb79a931c8622b0182eb6cb03011f4e681ad 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,7 +92,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DKokkos=InlineKokkos")
 
 #------------------------------------------------------
 # Pugs default compiler flags
-set(PUGS_CXX_FLAGS "${PUGS_CXX_FLAGS} -Wall -Wextra -pedantic")
+set(PUGS_CXX_FLAGS "${PUGS_CXX_FLAGS} -Wall -Wextra -pedantic -Wshadow")
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "${GNU_CXX_MIN_VERSION}")
diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp
index b67d81af335e3de1d3c02b0307351f03e75f8089..8a934ee2504c1e38872c8cf25b4d35b9c2f89d14 100644
--- a/src/language/ast/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp
@@ -154,13 +154,13 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
         ASTNode& parameters_name_node   = *function_descriptor.definitionNode().children[0];
 
         {   // Function data type
-          const std::string& symbol = n.children[0]->string();
+          const std::string& function_symbol = n.children[0]->string();
 
           std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;
 
-          auto [i_symbol, found] = symbol_table->find(symbol, n.children[0]->begin());
+          auto [i_function_symbol, found] = symbol_table->find(function_symbol, n.children[0]->begin());
           Assert(found);
-          i_symbol->attributes().setDataType(n.children[0]->m_data_type);
+          i_function_symbol->attributes().setDataType(n.children[0]->m_data_type);
         }
 
         const size_t nb_parameter_domains =
@@ -209,14 +209,14 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
             }
           }();
 
-          symbol_node.m_data_type   = data_type;
-          const std::string& symbol = symbol_node.string();
+          symbol_node.m_data_type             = data_type;
+          const std::string& symbol_node_name = symbol_node.string();
 
           std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;
 
-          auto [i_symbol, found] = symbol_table->find(symbol, symbol_node.begin());
+          auto [i_symbol_node_name, found] = symbol_table->find(symbol_node_name, symbol_node.begin());
           Assert(found);
-          i_symbol->attributes().setDataType(data_type);
+          i_symbol_node_name->attributes().setDataType(data_type);
         };
 
         if (parameters_domain_node.is_type<language::empty_set>() or
diff --git a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
index f4259526fb10a7d1977eec7c575e69c0837a4a26..1ceb09b0dd622251eb0f4a4e71390c897809f2bc 100644
--- a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
+++ b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
@@ -177,7 +177,7 @@ getBuiltinFunctionEmbedder(ASTNode& n)
     }
   }
 
-  uint64_t builtin_function_id = [&] {
+  const uint64_t builtin_function_id = [&] {
     switch (size(callable_id_list)) {
     case 0: {
       std::ostringstream error_msg;
@@ -186,14 +186,15 @@ getBuiltinFunctionEmbedder(ASTNode& n)
                 << rang::style::reset << rang::style::bold << "\nnote: candidates are";
 
       for (auto candidate : builtin_function_candidate_list) {
-        uint64_t builtin_function_id = std::get<uint64_t>(candidate.attributes().value());
+        uint64_t candidate_builtin_function_id = std::get<uint64_t>(candidate.attributes().value());
 
-        auto& builtin_function_embedder_table     = n.m_symbol_table->builtinFunctionEmbedderTable();
-        std::shared_ptr builtin_function_embedder = builtin_function_embedder_table[builtin_function_id];
+        auto& builtin_function_embedder_table = n.m_symbol_table->builtinFunctionEmbedderTable();
+        std::shared_ptr candidate_builtin_function_embedder =
+          builtin_function_embedder_table[candidate_builtin_function_id];
 
         error_msg << "\n " << builtin_function_name << ": "
-                  << dataTypeName(builtin_function_embedder->getParameterDataTypes()) << " -> "
-                  << dataTypeName(builtin_function_embedder->getReturnDataType());
+                  << dataTypeName(candidate_builtin_function_embedder->getParameterDataTypes()) << " -> "
+                  << dataTypeName(candidate_builtin_function_embedder->getReturnDataType());
       }
 
       throw ParseError(error_msg.str(), n.begin());
diff --git a/src/language/utils/DataVariant.cpp b/src/language/utils/DataVariant.cpp
index 005dda6f17f9d38cb2c9a7a63322244657f89e50..2525d999791204f0d2b2ed7466354bd6719c1e6a 100644
--- a/src/language/utils/DataVariant.cpp
+++ b/src/language/utils/DataVariant.cpp
@@ -4,7 +4,7 @@
 #include <utils/PugsTraits.hpp>
 
 std::ostream&
-operator<<(std::ostream& os, const DataVariant& v)
+operator<<(std::ostream& os, const DataVariant& data_variant)
 {
   std::visit(
     [&](auto&& v) {
@@ -29,7 +29,7 @@ operator<<(std::ostream& os, const DataVariant& v)
         os << v;
       }
     },
-    v);
+    data_variant);
 
   return os;
 }
diff --git a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
index ea842f84c24276323f8aa61865e8d1de470ef10d..0f9224fed185541ca8da8cdaaa10ffa777c978ad 100644
--- a/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
+++ b/src/language/utils/EmbeddedDiscreteFunctionMathFunctions.cpp
@@ -10,63 +10,63 @@
 
 #include <utils/Demangle.hpp>
 
-#define DISCRETE_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG)                                      \
-  return std::visit(                                                                             \
-    [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                  \
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                    \
-      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
-        return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function));           \
-      } else {                                                                                   \
-        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG));               \
-      }                                                                                          \
-    },                                                                                           \
+#define DISCRETE_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG)                                   \
+  return std::visit(                                                                          \
+    [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {               \
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;                    \
+      if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \
+        return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function));        \
+      } else {                                                                                \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG));            \
+      }                                                                                       \
+    },                                                                                        \
     ARG->discreteFunction());
 
-#define DISCRETE_VH_TO_R_CALL(FUNCTION, ARG)                                                     \
-  return std::visit(                                                                             \
-    [&](auto&& discrete_function) -> double {                                                    \
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                    \
-      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) { \
-        return FUNCTION(discrete_function);                                                      \
-      } else {                                                                                   \
-        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG));               \
-      }                                                                                          \
-    },                                                                                           \
+#define DISCRETE_VH_TO_R_CALL(FUNCTION, ARG)                                                  \
+  return std::visit(                                                                          \
+    [&](auto&& discrete_function) -> double {                                                 \
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;                    \
+      if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) { \
+        return FUNCTION(discrete_function);                                                   \
+      } else {                                                                                \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(ARG));            \
+      }                                                                                       \
+    },                                                                                        \
     ARG->discreteFunction());
 
-#define DISCRETE_VH_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                       \
-  if (not hasSameMesh({ARG0, ARG1})) {                                                      \
-    throw NormalError("operands are defined on different meshes");                          \
-  }                                                                                         \
-  return std::visit(                                                                        \
-    [&](auto&& f, auto&& g) -> std::shared_ptr<DiscreteFunctionVariant> {                   \
-      using TypeOfF = std::decay_t<decltype(f)>;                                            \
-      using TypeOfG = std::decay_t<decltype(g)>;                                            \
-      if constexpr (std::is_same_v<TypeOfF, DiscreteFunctionP0<1, const double>> or         \
-                    std::is_same_v<TypeOfF, DiscreteFunctionP0<2, const double>> or         \
-                    std::is_same_v<TypeOfF, DiscreteFunctionP0<3, const double>>) {         \
-        if constexpr (std::is_same_v<TypeOfF, TypeOfG>) {                                   \
-          return std::make_shared<DiscreteFunctionVariant>(FUNCTION(f, g));                 \
-        } else {                                                                            \
-          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g)); \
-        }                                                                                   \
-      } else {                                                                              \
-        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(f, g));   \
-      }                                                                                     \
-    },                                                                                      \
+#define DISCRETE_VH_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                               \
+  if (not hasSameMesh({ARG0, ARG1})) {                                                              \
+    throw NormalError("operands are defined on different meshes");                                  \
+  }                                                                                                 \
+  return std::visit(                                                                                \
+    [&](auto&& arg_f, auto&& arg_g) -> std::shared_ptr<DiscreteFunctionVariant> {                   \
+      using TypeOfF = std::decay_t<decltype(arg_f)>;                                                \
+      using TypeOfG = std::decay_t<decltype(arg_g)>;                                                \
+      if constexpr (std::is_same_v<TypeOfF, DiscreteFunctionP0<1, const double>> or                 \
+                    std::is_same_v<TypeOfF, DiscreteFunctionP0<2, const double>> or                 \
+                    std::is_same_v<TypeOfF, DiscreteFunctionP0<3, const double>>) {                 \
+        if constexpr (std::is_same_v<TypeOfF, TypeOfG>) {                                           \
+          return std::make_shared<DiscreteFunctionVariant>(FUNCTION(arg_f, arg_g));                 \
+        } else {                                                                                    \
+          throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(arg_f, arg_g)); \
+        }                                                                                           \
+      } else {                                                                                      \
+        throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(arg_f, arg_g));   \
+      }                                                                                             \
+    },                                                                                              \
     ARG0->discreteFunction(), ARG1->discreteFunction());
 
 #define DISCRETE_R_VH_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                                         \
   return std::visit(                                                                                         \
     [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                              \
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                                \
-      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or             \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or             \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) {             \
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;                                   \
+      if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or                \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or                \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) {                \
         return std::make_shared<DiscreteFunctionVariant>(FUNCTION(ARG0, discrete_function));                 \
       } else {                                                                                               \
         throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(ARG0, discrete_function)); \
@@ -77,10 +77,10 @@
 #define DISCRETE_VH_R_TO_VH_REAL_FUNCTION_CALL(FUNCTION, ARG0, ARG1)                                         \
   return std::visit(                                                                                         \
     [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {                              \
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;                                \
-      if constexpr (std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<1, const double>> or             \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<2, const double>> or             \
-                    std::is_same_v<DiscreteFunctionType, DiscreteFunctionP0<3, const double>>) {             \
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;                                   \
+      if constexpr (std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<1, const double>> or                \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<2, const double>> or                \
+                    std::is_same_v<DiscreteFunctionT, DiscreteFunctionP0<3, const double>>) {                \
         return std::make_shared<DiscreteFunctionVariant>(FUNCTION(discrete_function, ARG1));                 \
       } else {                                                                                               \
         throw NormalError(EmbeddedDiscreteFunctionUtils::incompatibleOperandTypes(discrete_function, ARG1)); \
@@ -330,11 +330,10 @@ det(const std::shared_ptr<const DiscreteFunctionVariant>& A)
 {
   return std::visit(
     [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
-          if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
-                        DiscreteFunctionType::data_type::NumberOfColumns) {
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+          if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(det(discrete_function));
           } else {
             throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -354,11 +353,10 @@ trace(const std::shared_ptr<const DiscreteFunctionVariant>& A)
 {
   return std::visit(
     [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
-          if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
-                        DiscreteFunctionType::data_type::NumberOfColumns) {
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+          if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(trace(discrete_function));
           } else {
             throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -378,11 +376,10 @@ inverse(const std::shared_ptr<const DiscreteFunctionVariant>& A)
 {
   return std::visit(
     [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
-          if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
-                        DiscreteFunctionType::data_type::NumberOfColumns) {
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+          if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(inverse(discrete_function));
           } else {
             throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -402,11 +399,10 @@ transpose(const std::shared_ptr<const DiscreteFunctionVariant>& A)
 {
   return std::visit(
     [&](auto&& discrete_function) -> std::shared_ptr<DiscreteFunctionVariant> {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionType::data_type>>) {
-          if constexpr (DiscreteFunctionType::data_type::NumberOfRows ==
-                        DiscreteFunctionType::data_type::NumberOfColumns) {
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+        if constexpr (is_tiny_matrix_v<std::decay_t<typename DiscreteFunctionT::data_type>>) {
+          if constexpr (DiscreteFunctionT::data_type::NumberOfRows == DiscreteFunctionT::data_type::NumberOfColumns) {
             return std::make_shared<DiscreteFunctionVariant>(transpose(discrete_function));
           } else {
             throw NormalError(EmbeddedDiscreteFunctionUtils::invalidOperandType(A));
@@ -476,9 +472,9 @@ sum_of(const std::shared_ptr<const DiscreteFunctionVariant>& f)
   ValueT value;
   std::visit(
     [&](auto&& discrete_function) {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-        using DataType = std::decay_t<typename DiscreteFunctionType::data_type>;
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+        using DataType = std::decay_t<typename DiscreteFunctionT::data_type>;
         if constexpr (std::is_same_v<ValueT, DataType>) {
           value = sum(discrete_function);
         } else {
@@ -498,9 +494,9 @@ sum_of_Vh_components(const std::shared_ptr<const DiscreteFunctionVariant>& f)
 {
   return std::visit(
     [&](auto&& discrete_function) -> std::shared_ptr<const DiscreteFunctionVariant> {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionType>) {
-        using DataType = std::decay_t<typename DiscreteFunctionType::data_type>;
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_vector_v<DiscreteFunctionT>) {
+        using DataType = std::decay_t<typename DiscreteFunctionT::data_type>;
         static_assert(std::is_same_v<DataType, double>);
         return std::make_shared<DiscreteFunctionVariant>(sumOfComponents(discrete_function));
       } else {
@@ -520,11 +516,10 @@ vectorize_to(const std::vector<std::shared_ptr<const DiscreteFunctionVariant>>&
     for (size_t i_discrete_function = 0; i_discrete_function < discrete_function_list.size(); ++i_discrete_function) {
       std::visit(
         [&](auto&& discrete_function) {
-          using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-          if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-            using DataType = std::remove_const_t<typename DiscreteFunctionType::data_type>;
-            if constexpr (std::is_same_v<DataType, double> and
-                          (Dimension == DiscreteFunctionType::MeshType::Dimension)) {
+          using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+          if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+            using DataType = std::remove_const_t<typename DiscreteFunctionT::data_type>;
+            if constexpr (std::is_same_v<DataType, double> and (Dimension == DiscreteFunctionT::MeshType::Dimension)) {
               const auto& connectivity = mesh.connectivity();
               parallel_for(
                 connectivity.numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
@@ -619,9 +614,9 @@ integral_of(const std::shared_ptr<const DiscreteFunctionVariant>& f)
 {
   return std::visit(
     [&](auto&& discrete_function) -> ValueT {
-      using DiscreteFunctionType = std::decay_t<decltype(discrete_function)>;
-      if constexpr (is_discrete_function_P0_v<DiscreteFunctionType>) {
-        using DataType = std::decay_t<typename DiscreteFunctionType::data_type>;
+      using DiscreteFunctionT = std::decay_t<decltype(discrete_function)>;
+      if constexpr (is_discrete_function_P0_v<DiscreteFunctionT>) {
+        using DataType = std::decay_t<typename DiscreteFunctionT::data_type>;
         if constexpr (std::is_same_v<ValueT, DataType>) {
           return integrate(discrete_function);
         } else {
diff --git a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp
index 48b51efba5aa8a9a9905247629e9e398a70ab17a..2ed94cbff4c8ee846e04674fd3e421f718577bfc 100644
--- a/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp
+++ b/src/language/utils/ItemArrayVariantFunctionInterpoler.cpp
@@ -58,17 +58,18 @@ ItemArrayVariantFunctionInterpoler::_interpolate() const
     Assert(function0_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::typename_t or
            function0_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::tuple_t);
 
-    ASTNodeDataType data_type = function0_descriptor.domainMappingNode().children[1]->m_data_type.contentType();
+    ASTNodeDataType data_type_candidate =
+      function0_descriptor.domainMappingNode().children[1]->m_data_type.contentType();
 
     for (size_t i = 1; i < m_function_id_list.size(); ++i) {
       const auto& function_descriptor = m_function_id_list[i].descriptor();
       Assert(function_descriptor.domainMappingNode().children[1]->m_data_type == ASTNodeDataType::typename_t);
-      if (data_type != function_descriptor.domainMappingNode().children[1]->m_data_type.contentType()) {
+      if (data_type_candidate != function_descriptor.domainMappingNode().children[1]->m_data_type.contentType()) {
         throw NormalError("functions must have the same type");
       }
     }
 
-    return data_type;
+    return data_type_candidate;
   }();
 
   switch (data_type) {
diff --git a/src/mesh/CartesianMeshBuilder.cpp b/src/mesh/CartesianMeshBuilder.cpp
index 9f6ea50cab88390669e3471ad3c70f25e870e390..226ff751fdf0b3316d66e2cb0c6e5366a9852d73 100644
--- a/src/mesh/CartesianMeshBuilder.cpp
+++ b/src/mesh/CartesianMeshBuilder.cpp
@@ -68,11 +68,11 @@ CartesianMeshBuilder::_getNodeCoordinates(const TinyVector<3>& a,
                                           const IConnectivity& connectivity) const
 {
   const TinyVector<3, uint64_t> node_size = [&] {
-    TinyVector node_size{cell_size};
+    TinyVector sizes_of_nodes{cell_size};
     for (size_t i = 0; i < 3; ++i) {
-      node_size[i] += 1;
+      sizes_of_nodes[i] += 1;
     }
-    return node_size;
+    return sizes_of_nodes;
   }();
 
   const auto node_logic_id = [&](size_t r) {
diff --git a/src/mesh/ConnectivityBuilderBase.cpp b/src/mesh/ConnectivityBuilderBase.cpp
index e7eb95fc6ed064805d12b5a8ece6e2844c37b9e9..f90e506d9edfdeb6242141e08ab9d46892aa6fca 100644
--- a/src/mesh/ConnectivityBuilderBase.cpp
+++ b/src/mesh/ConnectivityBuilderBase.cpp
@@ -100,7 +100,7 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
 
   Array<unsigned int> dup_faces_to_node_list(total_number_of_face_by_node);
   Array<unsigned int> dup_face_to_node_row(total_number_of_faces + 1);
-  size_t i_face           = 0;
+  size_t face_couter      = 0;
   dup_face_to_node_row[0] = 0;
 
   Array<unsigned short> cell_nb_faces(cell_to_node_matrix.numberOfRows());
@@ -119,12 +119,12 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
           cell_nb_faces[j] = 3;
           break;
         }
@@ -138,14 +138,14 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+          face_couter++;
           cell_nb_faces[j] = 4;
           break;
         }
@@ -156,8 +156,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
             dup_faces_to_node_list[i_face_node] = cell_nodes[(i + 1) % cell_nodes.size()];
             i_face_node++;
 
-            dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 2;
-            i_face++;
+            dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 2;
+            face_couter++;
           }
 
           cell_nb_faces[j] = cell_nodes.size();
@@ -177,48 +177,48 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[6];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[7];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[7];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[6];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[7];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[6];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           cell_nb_faces[j] = 6;
           break;
@@ -228,29 +228,29 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+          face_couter++;
 
           cell_nb_faces[j] = 4;
           break;
@@ -260,39 +260,39 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[1];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[4];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           dup_faces_to_node_list[i_face_node++] = cell_nodes[2];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[0];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[3];
           dup_faces_to_node_list[i_face_node++] = cell_nodes[5];
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 4;
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 4;
+          face_couter++;
 
           cell_nb_faces[j] = 5;
           break;
@@ -308,8 +308,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
             dup_faces_to_node_list[i_face_node++] = base_nodes[i];
           }
 
-          dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + base_nodes.size();
-          i_face++;
+          dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + base_nodes.size();
+          face_couter++;
 
           // side faces
           const auto pyramid_vertex = cell_nodes[cell_nodes.size() - 1];
@@ -318,8 +318,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
             dup_faces_to_node_list[i_face_node++] = base_nodes[i_node];
             dup_faces_to_node_list[i_face_node++] = pyramid_vertex;
 
-            dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-            i_face++;
+            dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+            face_couter++;
           }
           break;
         }
@@ -333,8 +333,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
               dup_faces_to_node_list[i_face_node++] = base_nodes((i_node + 1) % (cell_nodes.size() - 2));
               dup_faces_to_node_list[i_face_node++] = top_vertex;
 
-              dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-              i_face++;
+              dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+              face_couter++;
             }
           }
 
@@ -345,8 +345,8 @@ ConnectivityBuilderBase::_computeCellFaceAndFaceNodeConnectivities(ConnectivityD
               dup_faces_to_node_list[i_face_node++] = base_nodes(i_node);
               dup_faces_to_node_list[i_face_node++] = bottom_vertex;
 
-              dup_face_to_node_row[i_face + 1] = dup_face_to_node_row[i_face] + 3;
-              i_face++;
+              dup_face_to_node_row[face_couter + 1] = dup_face_to_node_row[face_couter] + 3;
+              face_couter++;
             }
           }
           cell_nb_faces[j] = 2 * (cell_nodes.size() - 2);
diff --git a/src/mesh/ConnectivityDispatcher.cpp b/src/mesh/ConnectivityDispatcher.cpp
index dde1f930d26d31faa21d06bf2b8d94568ccb93f1..65326b56bd49c1ce155dbf07fe32da8622c2e66c 100644
--- a/src/mesh/ConnectivityDispatcher.cpp
+++ b/src/mesh/ConnectivityDispatcher.cpp
@@ -294,7 +294,7 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc()
     using ItemId    = ItemIdT<SubItemOfItemT::item_type>;
     using SubItemId = ItemIdT<SubItemOfItemT::sub_item_type>;
 
-    std::vector<Array<const int>> sub_item_numbers_to_send_by_proc(parallel::size());
+    std::vector<Array<const int>> mutable_sub_item_numbers_to_send_by_proc(parallel::size());
     for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
       const auto& item_list_to_send_by_proc = this->_dispatchedInfo<SubItemOfItemT::item_type>().m_list_to_send_by_proc;
 
@@ -307,9 +307,9 @@ ConnectivityDispatcher<Dimension>::_buildSubItemNumbersToRecvByProc()
           sub_item_numbers_by_item_vector.push_back(sub_item_number[sub_item_id]);
         }
       }
-      sub_item_numbers_to_send_by_proc[i_rank] = convert_to_array(sub_item_numbers_by_item_vector);
+      mutable_sub_item_numbers_to_send_by_proc[i_rank] = convert_to_array(sub_item_numbers_by_item_vector);
     }
-    return sub_item_numbers_to_send_by_proc;
+    return mutable_sub_item_numbers_to_send_by_proc;
   }();
 
   const auto& number_of_sub_item_per_item_to_recv_by_proc =
@@ -416,8 +416,8 @@ ConnectivityDispatcher<Dimension>::_buildRecvItemIdCorrespondanceByProc()
   for (size_t i_rank = 0; i_rank < item_list_to_recv_size_by_proc.size(); ++i_rank) {
     Array<ItemId> item_id_correspondance(item_list_to_recv_size_by_proc[i_rank]);
     for (size_t l = 0; l < item_list_to_recv_size_by_proc[i_rank]; ++l) {
-      const int& item_number       = recv_item_number_by_proc[i_rank][l];
-      const auto& searched_item_id = item_number_to_id_map.find(item_number);
+      const int& recv_item_number  = recv_item_number_by_proc[i_rank][l];
+      const auto& searched_item_id = item_number_to_id_map.find(recv_item_number);
       Assert(searched_item_id != item_number_to_id_map.end());
       item_id_correspondance[l] = searched_item_id->second;
     }
@@ -438,11 +438,11 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
     parallel::allGather(m_connectivity.template numberOfRefItemList<item_type>());
 
   const size_t number_of_item_list_sender = [&]() {
-    size_t number_of_item_list_sender = 0;
+    size_t mutable_number_of_item_list_sender = 0;
     for (size_t i_rank = 0; i_rank < parallel::size(); ++i_rank) {
-      number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0);
+      mutable_number_of_item_list_sender += (number_of_item_ref_list_per_proc[i_rank] > 0);
     }
-    return number_of_item_list_sender;
+    return mutable_number_of_item_list_sender;
   }();
 
   if (number_of_item_list_sender > 0) {
@@ -512,15 +512,15 @@ ConnectivityDispatcher<Dimension>::_buildItemReferenceList()
       parallel::broadcast(ref_name_cat, sender_rank);
 
       std::vector<RefId> ref_id_list = [&]() {
-        std::vector<RefId> ref_id_list;
-        ref_id_list.reserve(ref_name_size_list.size());
+        std::vector<RefId> mutable_ref_id_list;
+        mutable_ref_id_list.reserve(ref_name_size_list.size());
         size_t begining = 0;
         for (size_t i_ref = 0; i_ref < ref_name_size_list.size(); ++i_ref) {
           const size_t size = ref_name_size_list[i_ref];
-          ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size});
+          mutable_ref_id_list.emplace_back(ref_tag_list[i_ref], std::string{&(ref_name_cat[begining]), size});
           begining += size;
         }
-        return ref_id_list;
+        return mutable_ref_id_list;
       }();
 
       using block_type            = int32_t;
diff --git a/src/mesh/DiamondDualConnectivityBuilder.cpp b/src/mesh/DiamondDualConnectivityBuilder.cpp
index 2cc1f47cd3be15c1012dda01c0c1c5b84ae66355..d170212a38d96628887ebb43ef154923990a5f04 100644
--- a/src/mesh/DiamondDualConnectivityBuilder.cpp
+++ b/src/mesh/DiamondDualConnectivityBuilder.cpp
@@ -216,11 +216,11 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
   const auto& node_number_vector = diamond_descriptor.nodeNumberVector();
   {
     const std::unordered_map<unsigned int, NodeId> node_to_id_map = [&] {
-      std::unordered_map<unsigned int, NodeId> node_to_id_map;
+      std::unordered_map<unsigned int, NodeId> mutable_node_to_id_map;
       for (size_t i_node = 0; i_node < node_number_vector.size(); ++i_node) {
-        node_to_id_map[node_number_vector[i_node]] = i_node;
+        mutable_node_to_id_map[node_number_vector[i_node]] = i_node;
       }
-      return node_to_id_map;
+      return mutable_node_to_id_map;
     }();
 
     for (size_t i_node_list = 0; i_node_list < primal_connectivity.template numberOfRefItemList<ItemType::node>();
@@ -229,17 +229,17 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
       const auto& primal_node_list     = primal_ref_node_list.list();
 
       const std::vector<NodeId> diamond_node_list = [&]() {
-        std::vector<NodeId> diamond_node_list;
+        std::vector<NodeId> mutable_diamond_node_list;
 
         for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) {
           auto primal_node_id       = primal_node_list[i_primal_node];
           const auto i_diamond_node = node_to_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]);
           if (i_diamond_node != node_to_id_map.end()) {
-            diamond_node_list.push_back(i_diamond_node->second);
+            mutable_diamond_node_list.push_back(i_diamond_node->second);
           }
         }
 
-        return diamond_node_list;
+        return mutable_diamond_node_list;
       }();
 
       if (parallel::allReduceOr(diamond_node_list.size() > 0)) {
@@ -286,31 +286,31 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
       const auto& primal_face_list     = primal_ref_face_list.list();
 
       const std::vector<FaceId> diamond_face_list = [&]() {
-        std::vector<FaceId> diamond_face_list;
-        diamond_face_list.reserve(primal_face_list.size());
-        for (size_t i = 0; i < primal_face_list.size(); ++i) {
-          FaceId primal_face_id = primal_face_list[i];
+        std::vector<FaceId> mutablt_diamond_face_list;
+        mutablt_diamond_face_list.reserve(primal_face_list.size());
+        for (size_t i_primal_face = 0; i_primal_face < primal_face_list.size(); ++i_primal_face) {
+          FaceId primal_face_id = primal_face_list[i_primal_face];
 
           const auto& primal_face_node_list = primal_face_to_node_matrix[primal_face_id];
 
           face_node_list.clear();
 
-          for (size_t i = 0; i < primal_face_node_list.size(); ++i) {
-            face_node_list.push_back(primal_face_node_list[i]);
+          for (size_t i_primal_face_noe = 0; i_primal_face_noe < primal_face_node_list.size(); ++i_primal_face_noe) {
+            face_node_list.push_back(primal_face_node_list[i_primal_face_noe]);
           }
 
           auto face_id = find_face(face_node_list);
           if (face_id.has_value()) {
-            diamond_face_list.push_back(face_id.value());
+            mutablt_diamond_face_list.push_back(face_id.value());
           }
         }
-        return diamond_face_list;
+        return mutablt_diamond_face_list;
       }();
 
       if (parallel::allReduceOr(diamond_face_list.size() > 0)) {
         Array<FaceId> face_array(diamond_face_list.size());
-        for (size_t i = 0; i < diamond_face_list.size(); ++i) {
-          face_array[i] = diamond_face_list[i];
+        for (size_t i_diamond_face = 0; i_diamond_face < diamond_face_list.size(); ++i_diamond_face) {
+          face_array[i_diamond_face] = diamond_face_list[i_diamond_face];
         }
         diamond_descriptor.addRefItemList(
           RefFaceList{primal_ref_face_list.refId(), face_array, primal_ref_face_list.type()});
@@ -361,8 +361,8 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
       const auto& primal_edge_list     = primal_ref_edge_list.list();
 
       const std::vector<EdgeId> diamond_edge_list = [&]() {
-        std::vector<EdgeId> diamond_edge_list;
-        diamond_edge_list.reserve(primal_edge_list.size());
+        std::vector<EdgeId> mutable_diamond_edge_list;
+        mutable_diamond_edge_list.reserve(primal_edge_list.size());
         for (size_t i = 0; i < primal_edge_list.size(); ++i) {
           EdgeId primal_edge_id = primal_edge_list[i];
 
@@ -371,10 +371,10 @@ DiamondDualConnectivityBuilder::_buildDiamondConnectivityFrom(const IConnectivit
           const auto diamond_edge_id = find_edge(primal_edge_node_list[0], primal_edge_node_list[1]);
 
           if (diamond_edge_id.has_value()) {
-            diamond_edge_list.push_back(diamond_edge_id.value());
+            mutable_diamond_edge_list.push_back(diamond_edge_id.value());
           }
         }
-        return diamond_edge_list;
+        return mutable_diamond_edge_list;
       }();
 
       if (parallel::allReduceOr(diamond_edge_list.size() > 0)) {
diff --git a/src/mesh/Dual1DConnectivityBuilder.cpp b/src/mesh/Dual1DConnectivityBuilder.cpp
index 9dd1c743edc0a07f578a4d7fd646ab96cfff490d..bc4f4bccc4b9055b65be7e9b103e124ef4d18eb2 100644
--- a/src/mesh/Dual1DConnectivityBuilder.cpp
+++ b/src/mesh/Dual1DConnectivityBuilder.cpp
@@ -74,14 +74,14 @@ Dual1DConnectivityBuilder::_buildConnectivityDescriptor(const Connectivity<1>& p
 
   Array<unsigned int> cell_to_node_list(cell_to_node_row[cell_to_node_row.size() - 1]);
   {
-    size_t next_kept_node_id = 0;
-    size_t i_cell_node       = 0;
+    size_t i_kept_node_id = 0;
+    size_t i_cell_node    = 0;
     for (NodeId i_node = 0; i_node < primal_connectivity.numberOfNodes(); ++i_node) {
       const auto& primal_node_cell_list = primal_node_to_cell_matrix[i_node];
       if (primal_node_cell_list.size() == 1) {
         const auto i_node_in_cell = primal_node_local_number_in_their_cells(i_node, 0);
 
-        cell_to_node_list[i_cell_node + i_node_in_cell]     = next_kept_node_id++;
+        cell_to_node_list[i_cell_node + i_node_in_cell]     = i_kept_node_id++;
         cell_to_node_list[i_cell_node + 1 - i_node_in_cell] = number_of_kept_nodes + primal_node_cell_list[0];
 
         i_cell_node += 2;
@@ -113,11 +113,11 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_
     const auto& dual_node_number_vector = dual_descriptor.nodeNumberVector();
 
     const std::unordered_map<unsigned int, NodeId> node_to_id_map = [&] {
-      std::unordered_map<unsigned int, NodeId> node_to_id_map;
+      std::unordered_map<unsigned int, NodeId> mutable_node_to_id_map;
       for (size_t i_node = 0; i_node < dual_node_number_vector.size(); ++i_node) {
-        node_to_id_map[dual_node_number_vector[i_node]] = i_node;
+        mutable_node_to_id_map[dual_node_number_vector[i_node]] = i_node;
       }
-      return node_to_id_map;
+      return mutable_node_to_id_map;
     }();
 
     for (size_t i_node_list = 0; i_node_list < primal_connectivity.template numberOfRefItemList<ItemType::node>();
@@ -126,17 +126,17 @@ Dual1DConnectivityBuilder::_buildConnectivityFrom(const IConnectivity& i_primal_
       const auto& primal_node_list     = primal_ref_node_list.list();
 
       const std::vector<NodeId> dual_node_list = [&]() {
-        std::vector<NodeId> dual_node_list;
+        std::vector<NodeId> mutable_dual_node_list;
 
         for (size_t i_primal_node = 0; i_primal_node < primal_node_list.size(); ++i_primal_node) {
           auto primal_node_id    = primal_node_list[i_primal_node];
           const auto i_dual_node = node_to_id_map.find(primal_connectivity.nodeNumber()[primal_node_id]);
           if (i_dual_node != node_to_id_map.end()) {
-            dual_node_list.push_back(i_dual_node->second);
+            mutable_dual_node_list.push_back(i_dual_node->second);
           }
         }
 
-        return dual_node_list;
+        return mutable_dual_node_list;
       }();
 
       if (parallel::allReduceOr(dual_node_list.size() > 0)) {
diff --git a/src/mesh/GmshReader.cpp b/src/mesh/GmshReader.cpp
index 73de0466d156f53a114494a1419b9ca506bfea26..e05dcaae592bcd4871f11de760ea1f17ee5221dd 100644
--- a/src/mesh/GmshReader.cpp
+++ b/src/mesh/GmshReader.cpp
@@ -251,12 +251,12 @@ GmshConnectivityBuilder<2>::GmshConnectivityBuilder(const GmshReader::GmshData&
 
   std::unordered_map<int, FaceId> face_number_id_map = [&] {
     const auto& face_number_vector = descriptor.faceNumberVector();
-    std::unordered_map<int, FaceId> face_number_id_map;
+    std::unordered_map<int, FaceId> mutable_face_number_id_map;
     for (size_t l = 0; l < face_number_vector.size(); ++l) {
-      face_number_id_map[face_number_vector[l]] = l;
+      mutable_face_number_id_map[face_number_vector[l]] = l;
     }
-    Assert(face_number_id_map.size() == face_number_vector.size());
-    return face_number_id_map;
+    Assert(mutable_face_number_id_map.size() == face_number_vector.size());
+    return mutable_face_number_id_map;
   }();
 
   const auto& node_number_vector  = descriptor.nodeNumberVector();
@@ -593,15 +593,15 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData&
     }
   }
 
-  const auto& face_number_vector = descriptor.faceNumberVector();
+  const auto& descriptor_face_number_vector = descriptor.faceNumberVector();
   {
     std::unordered_map<int, FaceId> face_number_id_map = [&] {
-      std::unordered_map<int, FaceId> face_number_id_map;
-      for (size_t l = 0; l < face_number_vector.size(); ++l) {
-        face_number_id_map[face_number_vector[l]] = l;
+      std::unordered_map<int, FaceId> mutable_face_number_id_map;
+      for (size_t l = 0; l < descriptor_face_number_vector.size(); ++l) {
+        mutable_face_number_id_map[descriptor_face_number_vector[l]] = l;
       }
-      Assert(face_number_id_map.size() == face_number_vector.size());
-      return face_number_id_map;
+      Assert(mutable_face_number_id_map.size() == descriptor_face_number_vector.size());
+      return mutable_face_number_id_map;
     }();
 
     const auto& node_to_face_matrix = descriptor.nodeToFaceMatrix();
@@ -799,12 +799,12 @@ GmshConnectivityBuilder<3>::GmshConnectivityBuilder(const GmshReader::GmshData&
 
     std::unordered_map<int, EdgeId> edge_number_id_map = [&] {
       const auto& edge_number_vector = descriptor.edgeNumberVector();
-      std::unordered_map<int, EdgeId> edge_number_id_map;
+      std::unordered_map<int, EdgeId> mutable_edge_number_id_map;
       for (size_t l = 0; l < edge_number_vector.size(); ++l) {
-        edge_number_id_map[edge_number_vector[l]] = l;
+        mutable_edge_number_id_map[edge_number_vector[l]] = l;
       }
-      Assert(edge_number_id_map.size() == edge_number_vector.size());
-      return edge_number_id_map;
+      Assert(mutable_edge_number_id_map.size() == edge_number_vector.size());
+      return mutable_edge_number_id_map;
     }();
 
     Array<int> edge_number_vector = copy(descriptor.edgeNumberVector());
@@ -1063,12 +1063,12 @@ GmshReader::GmshReader(const std::string& filename) : m_filename(filename)
     std::cout << "Sequential mesh read! Need to be dispatched\n" << std::flush;
 
     const int mesh_dimension = [&]() {
-      int mesh_dimension = -1;   // unknown mesh dimension
+      int mutable_mesh_dimension = -1;   // unknown mesh dimension
       if (m_mesh) {
-        mesh_dimension = m_mesh->dimension();
+        mutable_mesh_dimension = m_mesh->dimension();
       }
 
-      Array<int> dimensions = parallel::allGather(mesh_dimension);
+      Array<int> dimensions = parallel::allGather(mutable_mesh_dimension);
       std::set<int> dimension_set;
       for (size_t i = 0; i < dimensions.size(); ++i) {
         const int i_dimension = dimensions[i];
@@ -1196,8 +1196,8 @@ GmshReader::__readPeriodic2_2()
     [[maybe_unused]] const int master_id              = this->_getInteger();
     [[maybe_unused]] const int nb_corresponding_nodes = this->_getInteger();
     for (int i_node = 0; i_node < nb_corresponding_nodes; ++i_node) {
-      [[maybe_unused]] const int node_id   = this->_getInteger();
-      [[maybe_unused]] const int master_id = this->_getInteger();
+      [[maybe_unused]] const int node_id        = this->_getInteger();
+      [[maybe_unused]] const int node_master_id = this->_getInteger();
     }
   }
 }
diff --git a/src/mesh/LogicalConnectivityBuilder.cpp b/src/mesh/LogicalConnectivityBuilder.cpp
index 0fcbe6752f74f34adcec1d3a2a698ccbe253987a..df205e577a12edf19f4e4a3705ba58b1e89d2cdf 100644
--- a/src/mesh/LogicalConnectivityBuilder.cpp
+++ b/src/mesh/LogicalConnectivityBuilder.cpp
@@ -574,11 +574,11 @@ LogicalConnectivityBuilder::_buildConnectivity(const TinyVector<3, uint64_t>& ce
   constexpr size_t Dimension = 3;
 
   const TinyVector<Dimension, uint64_t> node_size = [&] {
-    TinyVector node_size{cell_size};
+    TinyVector mutable_node_size{cell_size};
     for (size_t i = 0; i < Dimension; ++i) {
-      node_size[i] += 1;
+      mutable_node_size[i] += 1;
     }
-    return node_size;
+    return mutable_node_size;
   }();
 
   auto count_items = [](auto&& v) {
diff --git a/src/mesh/MedianDualConnectivityBuilder.cpp b/src/mesh/MedianDualConnectivityBuilder.cpp
index ef4b260e4ce695a9386cac4f62396a129738a242..5f608943e2a5a7370b111bdabb842e6e52b48f27 100644
--- a/src/mesh/MedianDualConnectivityBuilder.cpp
+++ b/src/mesh/MedianDualConnectivityBuilder.cpp
@@ -33,9 +33,8 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
 
     parallel_reduce(
       primal_number_of_faces,
-      PUGS_LAMBDA(const FaceId face_id, size_t& number_of_boundary_faces) {
-        number_of_boundary_faces +=
-          (primal_face_is_owned[face_id] and (primal_face_to_cell_matrix[face_id].size() == 1));
+      PUGS_LAMBDA(const FaceId face_id, size_t& nb_of_boundary_faces) {
+        nb_of_boundary_faces += (primal_face_is_owned[face_id] and (primal_face_to_cell_matrix[face_id].size() == 1));
       },
       number_of_boundary_faces);
     return number_of_boundary_faces;
@@ -206,16 +205,17 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
 
       auto [face_id, cell_id] = [&]() -> std::pair<FaceId, CellId> {
         for (size_t i_face = 0; i_face < primal_node_to_face_list.size(); ++i_face) {
-          const FaceId face_id = primal_node_to_face_list[i_face];
-          if (primal_face_to_cell_matrix[face_id].size() > 1) {
+          const FaceId primal_face_id = primal_node_to_face_list[i_face];
+          if (primal_face_to_cell_matrix[primal_face_id].size() > 1) {
             continue;
           }
 
-          const CellId cell_id        = primal_face_to_cell_matrix[face_id][0];
-          const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(face_id, 0);
+          const CellId primal_cell_id = primal_face_to_cell_matrix[primal_face_id][0];
+          const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(primal_face_id, 0);
 
-          if (primal_face_to_node_matrix[face_id][primal_cell_face_is_reversed(cell_id, i_face_in_cell)] == node_id) {
-            return std::make_pair(face_id, cell_id);
+          if (primal_face_to_node_matrix[primal_face_id]
+                                        [primal_cell_face_is_reversed(primal_cell_id, i_face_in_cell)] == node_id) {
+            return std::make_pair(primal_face_id, primal_cell_id);
           }
         }
         // LCOV_EXCL_START
@@ -243,14 +243,15 @@ MedianDualConnectivityBuilder::_buildConnectivityDescriptor<2>(const Connectivit
       // inner cell
 
       auto [face_id, cell_id] = [&]() -> std::pair<FaceId, CellId> {
-        const FaceId face_id = primal_node_to_face_list[0];
+        const FaceId primal_face_id = primal_node_to_face_list[0];
 
-        for (size_t i_face_cell = 0; i_face_cell < primal_face_to_cell_matrix[face_id].size(); ++i_face_cell) {
-          const CellId cell_id        = primal_face_to_cell_matrix[face_id][i_face_cell];
-          const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(face_id, i_face_cell);
+        for (size_t i_face_cell = 0; i_face_cell < primal_face_to_cell_matrix[primal_face_id].size(); ++i_face_cell) {
+          const CellId primal_cell_id = primal_face_to_cell_matrix[primal_face_id][i_face_cell];
+          const size_t i_face_in_cell = primal_face_local_numbers_in_their_cells(primal_face_id, i_face_cell);
 
-          if (primal_face_to_node_matrix[face_id][primal_cell_face_is_reversed(cell_id, i_face_in_cell)] == node_id) {
-            return std::make_pair(face_id, cell_id);
+          if (primal_face_to_node_matrix[primal_face_id]
+                                        [primal_cell_face_is_reversed(primal_cell_id, i_face_in_cell)] == node_id) {
+            return std::make_pair(primal_face_id, primal_cell_id);
           }
         }
         // LCOV_EXCL_START
diff --git a/src/mesh/MeshBuilderBase.cpp b/src/mesh/MeshBuilderBase.cpp
index 973a6099afb49595d02403c697bbb927d2a7ba63..d2b27cd14c6680a99c4d6aba3281d36bcae1071b 100644
--- a/src/mesh/MeshBuilderBase.cpp
+++ b/src/mesh/MeshBuilderBase.cpp
@@ -91,8 +91,9 @@ MeshBuilderBase::_checkMesh() const
       if (intersection.size() > 1) {
         std::ostringstream error_msg;
         error_msg << "invalid mesh.\n\tFollowing edges\n";
-        for (EdgeId edge_id : intersection) {
-          error_msg << "\t - id=" << edge_id << " number=" << connectivity.edgeNumber()[edge_id] << '\n';
+        for (EdgeId duplicated_edge_id : intersection) {
+          error_msg << "\t - id=" << duplicated_edge_id << " number=" << connectivity.edgeNumber()[duplicated_edge_id]
+                    << '\n';
         }
         error_msg << "\tare duplicated";
         throw NormalError(error_msg.str());
@@ -179,8 +180,9 @@ MeshBuilderBase::_checkMesh() const
       if (intersection.size() > 1) {
         std::ostringstream error_msg;
         error_msg << "invalid mesh.\n\tFollowing cells\n";
-        for (CellId cell_id : intersection) {
-          error_msg << "\t - id=" << cell_id << " number=" << connectivity.cellNumber()[cell_id] << '\n';
+        for (CellId duplicated_cell_id : intersection) {
+          error_msg << "\t - id=" << duplicated_cell_id << " number=" << connectivity.cellNumber()[duplicated_cell_id]
+                    << '\n';
         }
         error_msg << "\tare duplicated";
         throw NormalError(error_msg.str());
diff --git a/src/mesh/MeshFlatNodeBoundary.cpp b/src/mesh/MeshFlatNodeBoundary.cpp
index 459a827c84ead76ed23acdf28cbd8525923694da..f5e60af046b49903304762aec86a237d7b2a868a 100644
--- a/src/mesh/MeshFlatNodeBoundary.cpp
+++ b/src/mesh/MeshFlatNodeBoundary.cpp
@@ -38,13 +38,13 @@ MeshFlatNodeBoundary<1>::_getNormal(const Mesh<Connectivity<1>>& mesh)
   using R = TinyVector<1, double>;
 
   const size_t number_of_bc_nodes = [&]() {
-    size_t number_of_bc_nodes = 0;
-    auto node_is_owned        = mesh.connectivity().nodeIsOwned();
-    auto node_list            = m_ref_node_list.list();
+    size_t nb_bc_nodes = 0;
+    auto node_is_owned = mesh.connectivity().nodeIsOwned();
+    auto node_list     = m_ref_node_list.list();
     for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
-      number_of_bc_nodes += (node_is_owned[node_list[i_node]]);
+      nb_bc_nodes += (node_is_owned[node_list[i_node]]);
     }
-    return parallel::allReduceMax(number_of_bc_nodes);
+    return parallel::allReduceMax(nb_bc_nodes);
   }();
 
   if (number_of_bc_nodes != 1) {
diff --git a/src/mesh/MeshNodeBoundary.cpp b/src/mesh/MeshNodeBoundary.cpp
index d97ee08bff9e38a7945490a2441b8e6348c84150..e883aa4eeb80b40962218208fc044f964a7d4a8d 100644
--- a/src/mesh/MeshNodeBoundary.cpp
+++ b/src/mesh/MeshNodeBoundary.cpp
@@ -20,15 +20,15 @@ MeshNodeBoundary<2>::_getBounds(const Mesh<Connectivity<2>>& mesh) const
   xmin = R2{std::numeric_limits<double>::max(), std::numeric_limits<double>::max()};
   xmax = R2{-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max()};
 
-  auto update_xmin = [](const R2& x, R2& xmin) {
-    if ((x[0] < xmin[0]) or ((x[0] == xmin[0]) and (x[1] < xmin[1]))) {
-      xmin = x;
+  auto update_xmin = [](const R2& x, R2& x_min) {
+    if ((x[0] < x_min[0]) or ((x[0] == x_min[0]) and (x[1] < x_min[1]))) {
+      x_min = x;
     }
   };
 
-  auto update_xmax = [](const R2& x, R2& xmax) {
-    if ((x[0] > xmax[0]) or ((x[0] == xmax[0]) and (x[1] > xmax[1]))) {
-      xmax = x;
+  auto update_xmax = [](const R2& x, R2& x_max) {
+    if ((x[0] > x_max[0]) or ((x[0] == x_max[0]) and (x[1] > x_max[1]))) {
+      x_max = x;
     }
   };
 
diff --git a/src/output/GnuplotWriter1D.cpp b/src/output/GnuplotWriter1D.cpp
index 3e0740446e961505eb01e36eee5ba168e0f47dcc..6b8da7a7e063caeac4cbcd64e577ba75d913fe13 100644
--- a/src/output/GnuplotWriter1D.cpp
+++ b/src/output/GnuplotWriter1D.cpp
@@ -148,12 +148,12 @@ GnuplotWriter1D::_writeItemDatas(const MeshType& mesh,
 {
   using ItemId = ItemIdT<item_type>;
 
-  const size_t& number_of_columns = [&] {
-    size_t number_of_columns = 1;
+  const size_t number_of_columns = [&] {
+    size_t nb_columns = 1;
     for (const auto& [name, item_data] : output_named_item_data_set) {
-      std::visit([&](auto&& value) { number_of_columns += _itemDataNbRow(value); }, item_data);
+      std::visit([&](auto&& value) { nb_columns += _itemDataNbRow(value); }, item_data);
     }
-    return number_of_columns;
+    return nb_columns;
   }();
 
   auto is_owned = mesh.connectivity().template isOwned<item_type>();
diff --git a/src/utils/Partitioner.cpp b/src/utils/Partitioner.cpp
index e63a4b48ccfdd57952d77797bbbee3344187352e..85e13c22d80f449c211f4c37ee20f3107556d6ba 100644
--- a/src/utils/Partitioner.cpp
+++ b/src/utils/Partitioner.cpp
@@ -37,14 +37,14 @@ Partitioner::partition(const CRSGraph& graph)
   MPI_Group mesh_group;
   std::vector<int> group_ranks = [&]() {
     Array<int> graph_node_owners = parallel::allGather(static_cast<int>(graph.numberOfNodes()));
-    std::vector<int> group_ranks;
-    group_ranks.reserve(graph_node_owners.size());
+    std::vector<int> grp_ranks;
+    grp_ranks.reserve(graph_node_owners.size());
     for (size_t i = 0; i < graph_node_owners.size(); ++i) {
       if (graph_node_owners[i] > 0) {
-        group_ranks.push_back(i);
+        grp_ranks.push_back(i);
       }
     }
-    return group_ranks;
+    return grp_ranks;
   }();
 
   MPI_Group_incl(world_group, group_ranks.size(), &(group_ranks[0]), &mesh_group);
diff --git a/tests/mpi_test_main.cpp b/tests/mpi_test_main.cpp
index fb0da8569382769cf495dedceb42a91528076dd9..ef3fdfcc00569ea3042de6724171fbd24e2ed680 100644
--- a/tests/mpi_test_main.cpp
+++ b/tests/mpi_test_main.cpp
@@ -81,11 +81,11 @@ main(int argc, char* argv[])
                     << '\n';
 
           for (size_t i_rank = 1; i_rank < parallel::size(); ++i_rank) {
-            std::filesystem::path parallel_output = std::filesystem::path{PUGS_BINARY_DIR}.append("tests");
-            parallel_output /= output_base_name + stringify(i_rank);
-            std::cout << " - " << rang::fg::green << parallel_output.parent_path().string()
-                      << parallel_output.preferred_separator << rang::style::reset << rang::fgB::green
-                      << parallel_output.filename().string() << rang::style::reset << '\n';
+            std::filesystem::path other_rank_output = std::filesystem::path{PUGS_BINARY_DIR}.append("tests");
+            other_rank_output /= output_base_name + stringify(i_rank);
+            std::cout << " - " << rang::fg::green << other_rank_output.parent_path().string()
+                      << other_rank_output.preferred_separator << rang::style::reset << rang::fgB::green
+                      << other_rank_output.filename().string() << rang::style::reset << '\n';
           }
         }
       }
diff --git a/tests/test_Array.cpp b/tests/test_Array.cpp
index 2651ecf43287fed07345f7fdbfef63e7d6f770a8..4a447f70a9e99151027266602763b712d00525cf 100644
--- a/tests/test_Array.cpp
+++ b/tests/test_Array.cpp
@@ -260,67 +260,67 @@ TEST_CASE("Array", "[utils]")
 
   SECTION("checking for Array reductions")
   {
-    Array<int> a(10);
-    a[0] = 13;
-    a[1] = 1;
-    a[2] = 8;
-    a[3] = -3;
-    a[4] = 23;
-    a[5] = -1;
-    a[6] = 13;
-    a[7] = 0;
-    a[8] = 12;
-    a[9] = 9;
+    Array<int> b(10);
+    b[0] = 13;
+    b[1] = 1;
+    b[2] = 8;
+    b[3] = -3;
+    b[4] = 23;
+    b[5] = -1;
+    b[6] = 13;
+    b[7] = 0;
+    b[8] = 12;
+    b[9] = 9;
 
     SECTION("Min")
     {
-      REQUIRE(min(a) == -3);
+      REQUIRE(min(b) == -3);
     }
 
     SECTION("Max")
     {
-      REQUIRE(max(a) == 23);
+      REQUIRE(max(b) == 23);
     }
 
     SECTION("Sum")
     {
-      REQUIRE((sum(a) == 75));
+      REQUIRE((sum(b) == 75));
     }
 
     SECTION("TinyVector Sum")
     {
       using N2 = TinyVector<2, int>;
-      Array<N2> b(10);
-      b[0] = N2{13, 2};
-      b[1] = N2{1, 3};
-      b[2] = N2{8, -2};
-      b[3] = N2{-3, 2};
-      b[4] = N2{23, 4};
-      b[5] = N2{-1, -3};
-      b[6] = N2{13, 17};
-      b[7] = N2{0, 9};
-      b[8] = N2{12, 13};
-      b[9] = N2{9, -17};
-
-      REQUIRE((sum(b) == N2{75, 28}));
+      Array<N2> c(10);
+      c[0] = N2{13, 2};
+      c[1] = N2{1, 3};
+      c[2] = N2{8, -2};
+      c[3] = N2{-3, 2};
+      c[4] = N2{23, 4};
+      c[5] = N2{-1, -3};
+      c[6] = N2{13, 17};
+      c[7] = N2{0, 9};
+      c[8] = N2{12, 13};
+      c[9] = N2{9, -17};
+
+      REQUIRE((sum(c) == N2{75, 28}));
     }
 
     SECTION("TinyMatrix Sum")
     {
       using N22 = TinyMatrix<2, 2, int>;
-      Array<N22> b(10);
-      b[0] = N22{13, 2, 0, 1};
-      b[1] = N22{1, 3, 6, 3};
-      b[2] = N22{8, -2, -1, 21};
-      b[3] = N22{-3, 2, 5, 12};
-      b[4] = N22{23, 4, 7, 1};
-      b[5] = N22{-1, -3, 33, 11};
-      b[6] = N22{13, 17, 12, 13};
-      b[7] = N22{0, 9, 1, 14};
-      b[8] = N22{12, 13, -3, -71};
-      b[9] = N22{9, -17, 0, 16};
-
-      REQUIRE((sum(b) == N22{75, 28, 60, 21}));
+      Array<N22> d(10);
+      d[0] = N22{13, 2, 0, 1};
+      d[1] = N22{1, 3, 6, 3};
+      d[2] = N22{8, -2, -1, 21};
+      d[3] = N22{-3, 2, 5, 12};
+      d[4] = N22{23, 4, 7, 1};
+      d[5] = N22{-1, -3, 33, 11};
+      d[6] = N22{13, 17, 12, 13};
+      d[7] = N22{0, 9, 1, 14};
+      d[8] = N22{12, 13, -3, -71};
+      d[9] = N22{9, -17, 0, 16};
+
+      REQUIRE((sum(d) == N22{75, 28, 60, 21}));
     }
   }
 
diff --git a/tests/test_BuiltinFunctionEmbedder.cpp b/tests/test_BuiltinFunctionEmbedder.cpp
index 31cde714627687bb0aee8f62ff122cf2e5ae0a1b..be28e7d75a42240f2f2e248e8cade2261e5ef5e5 100644
--- a/tests/test_BuiltinFunctionEmbedder.cpp
+++ b/tests/test_BuiltinFunctionEmbedder.cpp
@@ -204,11 +204,11 @@ TEST_CASE("BuiltinFunctionEmbedder", "[language]")
   SECTION("uint64_t(std::vector<uint64_t>) BuiltinFunctionEmbedder")
   {
     std::function sum = [&](const std::vector<uint64_t>& x) -> uint64_t {
-      uint64_t sum = 0;
+      uint64_t s = 0;
       for (size_t i = 0; i < x.size(); ++i) {
-        sum += x[i];
+        s += x[i];
       }
-      return sum;
+      return s;
     };
 
     std::unique_ptr<IBuiltinFunctionEmbedder> i_embedded_c =
@@ -234,11 +234,11 @@ TEST_CASE("BuiltinFunctionEmbedder", "[language]")
   SECTION("uint64_t(std::vector<EmbeddedData>) BuiltinFunctionEmbedder")
   {
     std::function sum = [&](const std::vector<std::shared_ptr<const uint64_t>>& x) -> uint64_t {
-      uint64_t sum = 0;
+      uint64_t s = 0;
       for (size_t i = 0; i < x.size(); ++i) {
-        sum += *x[i];
+        s += *x[i];
       }
-      return sum;
+      return s;
     };
 
     std::unique_ptr<IBuiltinFunctionEmbedder> i_embedded_c =
diff --git a/tests/test_BuiltinFunctionProcessor.cpp b/tests/test_BuiltinFunctionProcessor.cpp
index de04b76016ad02a78130574129b74d95ca38ba94..b678612fe2c338b641b1e66c6ccce9ae65454b8f 100644
--- a/tests/test_BuiltinFunctionProcessor.cpp
+++ b/tests/test_BuiltinFunctionProcessor.cpp
@@ -42,7 +42,7 @@
     position use_position{10000, 1000, 10, "fixture"};                                                                \
     auto [symbol, found] = symbol_table->find(variable_name, use_position);                                           \
                                                                                                                       \
-    REQUIRE_THAT(found, Catch::Matchers::Predicate<bool>([](bool found) -> bool { return found; },                    \
+    REQUIRE_THAT(found, Catch::Matchers::Predicate<bool>([](bool is_found) -> bool { return is_found; },              \
                                                          std::string{"Cannot find symbol '"} + variable_name + "'")); \
                                                                                                                       \
     auto attributes = symbol->attributes();                                                                           \
diff --git a/tests/test_CellIntegrator.cpp b/tests/test_CellIntegrator.cpp
index 7c70d19fd2a538f831507d7eeb41392b0686f158..9b286a44508726c5a286964a89e8acec80ef12ec 100644
--- a/tests/test_CellIntegrator.cpp
+++ b/tests/test_CellIntegrator.cpp
@@ -1156,8 +1156,6 @@ TEST_CASE("CellIntegrator", "[scheme]")
 
     SECTION("2D")
     {
-      using R2 = TinyVector<2>;
-
       const auto mesh = MeshDataBaseForTests::get().hybrid2DMesh();
 
       auto f = [](const R2& X) -> R2 {
diff --git a/tests/test_CubeTransformation.cpp b/tests/test_CubeTransformation.cpp
index 346dd3c4e9b1f3412bb53503c6880ea07a1508e6..e719ea5aaa5c99f659fdad31ca3b3d844b3623ac 100644
--- a/tests/test_CubeTransformation.cpp
+++ b/tests/test_CubeTransformation.cpp
@@ -151,8 +151,6 @@ TEST_CASE("CubeTransformation", "[geometry]")
 
   SECTION("degenerate to tetrahedron")
   {
-    using R3 = TinyVector<3>;
-
     const R3 a{1, 2, 1};
     const R3 b{3, 1, 3};
     const R3 c{2, 5, 2};
diff --git a/tests/test_DiscreteFunctionP0.cpp b/tests/test_DiscreteFunctionP0.cpp
index d0f71e984d516ec243de289f399d882663c9c499..d7d4dff52124e734b1d0d5f6bce1d402fa0f680d 100644
--- a/tests/test_DiscreteFunctionP0.cpp
+++ b/tests/test_DiscreteFunctionP0.cpp
@@ -47,14 +47,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()};
           h_values.fill(ZeroType{});
 
-          DiscreteFunctionP0 zero{mesh, [&] {
-                                    CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
-                                    cell_value.fill(ZeroType{});
-                                    return cell_value;
-                                  }()};
+          DiscreteFunctionP0 zero_function{mesh, [&] {
+                                             CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
+                                             cell_value.fill(ZeroType{});
+                                             return cell_value;
+                                           }()};
 
           DiscreteFunctionP0 h{mesh, h_values};
-          REQUIRE(same_values(h, zero));
+          REQUIRE(same_values(h, zero_function));
           REQUIRE(same_values(h, h_values));
 
           DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh};
@@ -64,7 +64,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
 
           REQUIRE(same_values(shallow_h, h_values));
           REQUIRE(same_values(h, h_values));
-          REQUIRE(not same_values(h, zero));
+          REQUIRE(not same_values(h, zero_function));
 
           DiscreteFunctionP0 moved_h{std::move(h)};
           REQUIRE(same_values(moved_h, h_values));
@@ -95,14 +95,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()};
           h_values.fill(ZeroType{});
 
-          DiscreteFunctionP0 zero{mesh, [&] {
-                                    CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
-                                    cell_value.fill(ZeroType{});
-                                    return cell_value;
-                                  }()};
+          DiscreteFunctionP0 zero_function{mesh, [&] {
+                                             CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
+                                             cell_value.fill(ZeroType{});
+                                             return cell_value;
+                                           }()};
 
           DiscreteFunctionP0 h{mesh, h_values};
-          REQUIRE(same_values(h, zero));
+          REQUIRE(same_values(h, zero_function));
           REQUIRE(same_values(h, h_values));
 
           DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh};
@@ -112,7 +112,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
 
           REQUIRE(same_values(shallow_h, h_values));
           REQUIRE(same_values(h, h_values));
-          REQUIRE(not same_values(h, zero));
+          REQUIRE(not same_values(h, zero_function));
 
           DiscreteFunctionP0 moved_h{std::move(h)};
           REQUIRE(same_values(moved_h, h_values));
@@ -144,14 +144,14 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           CellValue<TinyVector<Dimension>> h_values{mesh->connectivity()};
           h_values.fill(ZeroType{});
 
-          DiscreteFunctionP0 zero{mesh, [&] {
-                                    CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
-                                    cell_value.fill(ZeroType{});
-                                    return cell_value;
-                                  }()};
+          DiscreteFunctionP0 zero_function{mesh, [&] {
+                                             CellValue<TinyVector<Dimension>> cell_value{mesh->connectivity()};
+                                             cell_value.fill(ZeroType{});
+                                             return cell_value;
+                                           }()};
 
           DiscreteFunctionP0 h{mesh, h_values};
-          REQUIRE(same_values(h, zero));
+          REQUIRE(same_values(h, zero_function));
           REQUIRE(same_values(h, h_values));
 
           DiscreteFunctionP0<Dimension, TinyVector<Dimension>> shallow_h{mesh};
@@ -161,7 +161,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
 
           REQUIRE(same_values(shallow_h, h_values));
           REQUIRE(same_values(h, h_values));
-          REQUIRE(not same_values(h, zero));
+          REQUIRE(not same_values(h, zero_function));
 
           DiscreteFunctionP0 moved_h{std::move(h)};
           REQUIRE(same_values(moved_h, h_values));
@@ -295,8 +295,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
 
           SECTION("scalar")
           {
-            const size_t value = parallel::rank() + 1;
-            const size_t zero  = 0;
+            const size_t value      = parallel::rank() + 1;
+            const size_t zero_value = 0;
 
             DiscreteFunctionP0<Dimension, size_t> f{mesh};
             f.fill(value);
@@ -304,18 +304,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_value);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_value));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_value);
 
             DiscreteFunctionP0<Dimension, const size_t> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_value));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -326,25 +326,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           SECTION("vector")
           {
             const TinyVector<2, size_t> value{parallel::rank() + 1, 3};
-            const TinyVector<2, size_t> zero{ZeroType{}};
+            const TinyVector<2, size_t> zero_vector{ZeroType{}};
             DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh};
             f.fill(value);
 
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_vector);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_vector));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_vector);
 
             DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_vector));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -355,25 +355,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           SECTION("matrix")
           {
             const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9};
-            const TinyMatrix<3, 3, size_t> zero{ZeroType{}};
+            const TinyMatrix<3, 3, size_t> zero_matrix{ZeroType{}};
             DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh};
             f.fill(value);
 
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_matrix);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_matrix));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_matrix);
 
             DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_matrix));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -397,8 +397,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
 
           SECTION("scalar")
           {
-            const size_t value = parallel::rank() + 1;
-            const size_t zero  = 0;
+            const size_t value      = parallel::rank() + 1;
+            const size_t zero_value = 0;
 
             DiscreteFunctionP0<Dimension, size_t> f{mesh};
             f.fill(value);
@@ -406,18 +406,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_value);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_value));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_value);
 
             DiscreteFunctionP0<Dimension, const size_t> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_value));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -428,25 +428,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           SECTION("vector")
           {
             const TinyVector<2, size_t> value{parallel::rank() + 1, 3};
-            const TinyVector<2, size_t> zero{ZeroType{}};
+            const TinyVector<2, size_t> zero_vector{ZeroType{}};
             DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh};
             f.fill(value);
 
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_vector);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_vector));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_vector);
 
             DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_vector));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -457,25 +457,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           SECTION("matrix")
           {
             const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9};
-            const TinyMatrix<3, 3, size_t> zero{ZeroType{}};
+            const TinyMatrix<3, 3, size_t> zero_vector{ZeroType{}};
             DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh};
             f.fill(value);
 
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_vector);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_vector));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_vector);
 
             DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_vector));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -499,8 +499,8 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
 
           SECTION("scalar")
           {
-            const size_t value = parallel::rank() + 1;
-            const size_t zero  = 0;
+            const size_t value      = parallel::rank() + 1;
+            const size_t zero_value = 0;
 
             DiscreteFunctionP0<Dimension, size_t> f{mesh};
             f.fill(value);
@@ -508,18 +508,18 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_value);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_value));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_value);
 
             DiscreteFunctionP0<Dimension, const size_t> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_value));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -530,25 +530,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           SECTION("vector")
           {
             const TinyVector<2, size_t> value{parallel::rank() + 1, 3};
-            const TinyVector<2, size_t> zero{ZeroType{}};
+            const TinyVector<2, size_t> zero_vector{ZeroType{}};
             DiscreteFunctionP0<Dimension, TinyVector<2, size_t>> f{mesh};
             f.fill(value);
 
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_vector);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_vector));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_vector);
 
             DiscreteFunctionP0<Dimension, const TinyVector<2, size_t>> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_vector));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -559,25 +559,25 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
           SECTION("matrix")
           {
             const TinyMatrix<3, 3, size_t> value{1, 2, 3, 4, 5, 6, 7, 8, 9};
-            const TinyMatrix<3, 3, size_t> zero{ZeroType{}};
+            const TinyMatrix<3, 3, size_t> zero_matrix{ZeroType{}};
             DiscreteFunctionP0<Dimension, TinyMatrix<3, 3, size_t>> f{mesh};
             f.fill(value);
 
             REQUIRE(all_values_equal(f, value));
 
             DiscreteFunctionP0 g = copy(f);
-            f.fill(zero);
+            f.fill(zero_matrix);
 
-            REQUIRE(all_values_equal(f, zero));
+            REQUIRE(all_values_equal(f, zero_matrix));
             REQUIRE(all_values_equal(g, value));
 
             copy_to(g, f);
-            g.fill(zero);
+            g.fill(zero_matrix);
 
             DiscreteFunctionP0<Dimension, const TinyMatrix<3, 3, size_t>> h = copy(f);
 
             REQUIRE(all_values_equal(f, value));
-            REQUIRE(all_values_equal(g, zero));
+            REQUIRE(all_values_equal(g, zero_matrix));
             REQUIRE(all_values_equal(h, value));
 
             copy_to(h, g);
@@ -3439,7 +3439,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3461,7 +3461,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3483,7 +3483,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
@@ -3505,7 +3505,7 @@ TEST_CASE("DiscreteFunctionP0", "[scheme]")
               mesh->numberOfCells(), PUGS_LAMBDA(const CellId cell_id) {
                 const double x = xj[cell_id][0];
                 Ah[cell_id]    = TinyMatrix<2>{x + 1, 2 * x - 3,   //
-                                            -0.2 * x - 1, 2 + x};
+                                               -0.2 * x - 1, 2 + x};
               });
 
             {
diff --git a/tests/test_DiscreteFunctionP0Vector.cpp b/tests/test_DiscreteFunctionP0Vector.cpp
index d2da3d84ef517f28dc0bd0ba60149be7c4fba725..2ab61b2405ba5eb098663db5fa6a3d26b6fe75b9 100644
--- a/tests/test_DiscreteFunctionP0Vector.cpp
+++ b/tests/test_DiscreteFunctionP0Vector.cpp
@@ -50,20 +50,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           CellArray<double> h_arrays{mesh->connectivity(), size};
           h_arrays.fill(0);
 
-          DiscreteFunctionP0Vector zero{mesh, [&] {
-                                          CellArray<double> cell_array{mesh->connectivity(), size};
-                                          cell_array.fill(0);
-                                          return cell_array;
-                                        }()};
+          DiscreteFunctionP0Vector zero_function{mesh, [&] {
+                                                   CellArray<double> cell_array{mesh->connectivity(), size};
+                                                   cell_array.fill(0);
+                                                   return cell_array;
+                                                 }()};
 
           DiscreteFunctionP0Vector h{mesh, h_arrays};
-          REQUIRE(same_values(h, zero));
+          REQUIRE(same_values(h, zero_function));
           REQUIRE(same_values(h, h_arrays));
 
           h_arrays.fill(1);
 
           REQUIRE(same_values(h, h_arrays));
-          REQUIRE(not same_values(h, zero));
+          REQUIRE(not same_values(h, zero_function));
 
           DiscreteFunctionP0Vector moved_h{std::move(h)};
           REQUIRE(same_values(moved_h, h_arrays));
@@ -98,20 +98,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           CellArray<double> h_arrays{mesh->connectivity(), size};
           h_arrays.fill(0);
 
-          DiscreteFunctionP0Vector zero{mesh, [&] {
-                                          CellArray<double> cell_array{mesh->connectivity(), size};
-                                          cell_array.fill(0);
-                                          return cell_array;
-                                        }()};
+          DiscreteFunctionP0Vector zero_function{mesh, [&] {
+                                                   CellArray<double> cell_array{mesh->connectivity(), size};
+                                                   cell_array.fill(0);
+                                                   return cell_array;
+                                                 }()};
 
           DiscreteFunctionP0Vector h{mesh, h_arrays};
-          REQUIRE(same_values(h, zero));
+          REQUIRE(same_values(h, zero_function));
           REQUIRE(same_values(h, h_arrays));
 
           h_arrays.fill(1);
 
           REQUIRE(same_values(h, h_arrays));
-          REQUIRE(not same_values(h, zero));
+          REQUIRE(not same_values(h, zero_function));
 
           DiscreteFunctionP0Vector moved_h{std::move(h)};
           REQUIRE(same_values(moved_h, h_arrays));
@@ -146,20 +146,20 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           CellArray<double> h_arrays{mesh->connectivity(), size};
           h_arrays.fill(0);
 
-          DiscreteFunctionP0Vector zero{mesh, [&] {
-                                          CellArray<double> cell_array{mesh->connectivity(), size};
-                                          cell_array.fill(0);
-                                          return cell_array;
-                                        }()};
+          DiscreteFunctionP0Vector zero_function{mesh, [&] {
+                                                   CellArray<double> cell_array{mesh->connectivity(), size};
+                                                   cell_array.fill(0);
+                                                   return cell_array;
+                                                 }()};
 
           DiscreteFunctionP0Vector h{mesh, h_arrays};
-          REQUIRE(same_values(h, zero));
+          REQUIRE(same_values(h, zero_function));
           REQUIRE(same_values(h, h_arrays));
 
           h_arrays.fill(1);
 
           REQUIRE(same_values(h, h_arrays));
-          REQUIRE(not same_values(h, zero));
+          REQUIRE(not same_values(h, zero_function));
 
           DiscreteFunctionP0Vector moved_h{std::move(h)};
           REQUIRE(same_values(moved_h, h_arrays));
@@ -271,9 +271,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
         {
           auto mesh = named_mesh.mesh();
 
-          const size_t size  = 3;
-          const size_t value = parallel::rank() + 1;
-          const size_t zero  = 0;
+          const size_t size       = 3;
+          const size_t value      = parallel::rank() + 1;
+          const size_t zero_value = 0;
 
           DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size};
           f.fill(value);
@@ -281,13 +281,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           REQUIRE(all_values_equal(f, value));
 
           DiscreteFunctionP0Vector g = copy(f);
-          f.fill(zero);
+          f.fill(zero_value);
 
-          REQUIRE(all_values_equal(f, zero));
+          REQUIRE(all_values_equal(f, zero_value));
           REQUIRE(all_values_equal(g, value));
 
           copy_to(g, f);
-          g.fill(zero);
+          g.fill(zero_value);
 
           DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f);
 
@@ -295,8 +295,8 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           shallow_g = g;
 
           REQUIRE(all_values_equal(f, value));
-          REQUIRE(all_values_equal(g, zero));
-          REQUIRE(all_values_equal(shallow_g, zero));
+          REQUIRE(all_values_equal(g, zero_value));
+          REQUIRE(all_values_equal(shallow_g, zero_value));
           REQUIRE(all_values_equal(h, value));
 
           copy_to(h, g);
@@ -317,9 +317,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
         {
           auto mesh = named_mesh.mesh();
 
-          const size_t size  = 3;
-          const size_t value = parallel::rank() + 1;
-          const size_t zero  = 0;
+          const size_t size       = 3;
+          const size_t value      = parallel::rank() + 1;
+          const size_t zero_value = 0;
 
           DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size};
           f.fill(value);
@@ -327,13 +327,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           REQUIRE(all_values_equal(f, value));
 
           DiscreteFunctionP0Vector g = copy(f);
-          f.fill(zero);
+          f.fill(zero_value);
 
-          REQUIRE(all_values_equal(f, zero));
+          REQUIRE(all_values_equal(f, zero_value));
           REQUIRE(all_values_equal(g, value));
 
           copy_to(g, f);
-          g.fill(zero);
+          g.fill(zero_value);
 
           DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f);
 
@@ -341,8 +341,8 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           shallow_g = g;
 
           REQUIRE(all_values_equal(f, value));
-          REQUIRE(all_values_equal(g, zero));
-          REQUIRE(all_values_equal(shallow_g, zero));
+          REQUIRE(all_values_equal(g, zero_value));
+          REQUIRE(all_values_equal(shallow_g, zero_value));
           REQUIRE(all_values_equal(h, value));
 
           copy_to(h, g);
@@ -364,9 +364,9 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
         {
           auto mesh = named_mesh.mesh();
 
-          const size_t size  = 3;
-          const size_t value = parallel::rank() + 1;
-          const size_t zero  = 0;
+          const size_t size       = 3;
+          const size_t value      = parallel::rank() + 1;
+          const size_t zero_value = 0;
 
           DiscreteFunctionP0Vector<Dimension, size_t> f{mesh, size};
           f.fill(value);
@@ -374,13 +374,13 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           REQUIRE(all_values_equal(f, value));
 
           DiscreteFunctionP0Vector g = copy(f);
-          f.fill(zero);
+          f.fill(zero_value);
 
-          REQUIRE(all_values_equal(f, zero));
+          REQUIRE(all_values_equal(f, zero_value));
           REQUIRE(all_values_equal(g, value));
 
           copy_to(g, f);
-          g.fill(zero);
+          g.fill(zero_value);
 
           DiscreteFunctionP0Vector<Dimension, const size_t> h = copy(f);
 
@@ -388,7 +388,7 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           shallow_g = g;
 
           REQUIRE(all_values_equal(f, value));
-          REQUIRE(all_values_equal(g, zero));
+          REQUIRE(all_values_equal(g, zero_value));
           REQUIRE(all_values_equal(h, value));
 
           copy_to(h, g);
@@ -573,10 +573,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           DiscreteFunctionP0Vector<Dimension, const double> const_f = f;
           DiscreteFunctionP0Vector<Dimension, const double> const_g{g};
 
-          auto same_data = [](const auto& f, const auto& g) {
-            const size_t number_of_cells = g.size();
+          auto same_data = [](const auto& f0, const auto& f1) {
+            const size_t number_of_cells = f1.size();
             for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) {
-              if (f[cell_id] != g[cell_id]) {
+              if (f0[cell_id] != f1[cell_id]) {
                 return false;
               }
             }
@@ -656,10 +656,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           DiscreteFunctionP0Vector<Dimension, const double> const_f = f;
           DiscreteFunctionP0Vector<Dimension, const double> const_g{g};
 
-          auto same_data = [](const auto& f, const auto& g) {
-            const size_t number_of_cells = g.size();
+          auto same_data = [](const auto& f1, const auto& f2) {
+            const size_t number_of_cells = f2.size();
             for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) {
-              if (f[cell_id] != g[cell_id]) {
+              if (f1[cell_id] != f2[cell_id]) {
                 return false;
               }
             }
@@ -739,10 +739,10 @@ TEST_CASE("DiscreteFunctionP0Vector", "[scheme]")
           DiscreteFunctionP0Vector<Dimension, const double> const_f = f;
           DiscreteFunctionP0Vector<Dimension, const double> const_g{g};
 
-          auto same_data = [](const auto& f, const auto& g) {
-            const size_t number_of_cells = g.size();
+          auto same_data = [](const auto& f1, const auto& f2) {
+            const size_t number_of_cells = f2.size();
             for (CellId cell_id = 0; cell_id < number_of_cells; ++cell_id) {
-              if (f[cell_id] != g[cell_id]) {
+              if (f1[cell_id] != f2[cell_id]) {
                 return false;
               }
             }
diff --git a/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp b/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp
index bfa17ffc7609a8a304ee5dd36b3574782fbba464..7da58023559d83d7c554c2cc2d0aa44282508e30 100644
--- a/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp
+++ b/tests/test_EmbeddedDiscreteFunctionMathFunctions.hpp
@@ -10,11 +10,11 @@
     const U_TYPE& u   = P_U->get<U_TYPE>();                                    \
     const FU_TYPE& fu = p_fu->get<FU_TYPE>();                                  \
                                                                                \
-    bool is_same = true;                                                       \
-    auto values  = u.cellValues();                                             \
-    for (CellId cell_id = 0; cell_id < values.numberOfItems(); ++cell_id) {    \
+    bool is_same  = true;                                                      \
+    auto u_values = u.cellValues();                                            \
+    for (CellId cell_id = 0; cell_id < u_values.numberOfItems(); ++cell_id) {  \
       using namespace std;                                                     \
-      if (fu[cell_id] != FCT(values[cell_id])) {                               \
+      if (fu[cell_id] != FCT(u_values[cell_id])) {                             \
         is_same = false;                                                       \
         break;                                                                 \
       }                                                                        \
diff --git a/tests/test_ItemArray.cpp b/tests/test_ItemArray.cpp
index 2dbe964f3cdd5733aa77ddf5e1bc9204e9731998..644f348c6ae2df4dcf56c87816d1b3b9c323a1a1 100644
--- a/tests/test_ItemArray.cpp
+++ b/tests/test_ItemArray.cpp
@@ -157,15 +157,15 @@ TEST_CASE("ItemArray", "[mesh]")
 
         CellArray<size_t> cell_array{connectivity, table};
 
-        auto is_same = [](const CellArray<size_t>& cell_array, const Table<size_t>& table) {
-          bool is_same = true;
-          for (CellId cell_id = 0; cell_id < cell_array.numberOfItems(); ++cell_id) {
-            auto sub_array = cell_array[cell_id];
+        auto is_same = [](const CellArray<size_t>& a_cell_array, const Table<size_t>& a_table) {
+          bool same = true;
+          for (CellId cell_id = 0; cell_id < a_cell_array.numberOfItems(); ++cell_id) {
+            auto sub_array = a_cell_array[cell_id];
             for (size_t i = 0; i < sub_array.size(); ++i) {
-              is_same &= (sub_array[i] == table(cell_id, i));
+              same &= (sub_array[i] == a_table(cell_id, i));
             }
           }
-          return is_same;
+          return same;
         };
 
         REQUIRE(is_same(cell_array, table));
@@ -177,14 +177,14 @@ TEST_CASE("ItemArray", "[mesh]")
   SECTION("copy")
   {
     auto is_same = [](const auto& cell_array, int value) {
-      bool is_same = true;
+      bool same = true;
       for (CellId cell_id = 0; cell_id < cell_array.numberOfItems(); ++cell_id) {
         auto sub_array = cell_array[cell_id];
         for (size_t i = 0; i < sub_array.size(); ++i) {
-          is_same &= (sub_array[i] == value);
+          same &= (sub_array[i] == value);
         }
       }
-      return is_same;
+      return same;
     };
 
     std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
@@ -367,12 +367,12 @@ TEST_CASE("ItemArray", "[mesh]")
 
           const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
 
-          std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
+          std::array mesh_3d_list = MeshDataBaseForTests::get().all3DMeshes();
 
-          for (const auto& named_mesh : mesh_list) {
-            SECTION(named_mesh.name())
+          for (const auto& named_mesh_3d : mesh_3d_list) {
+            SECTION(named_mesh_3d.name())
             {
-              auto mesh_3d = named_mesh.mesh();
+              auto mesh_3d = named_mesh_3d.mesh();
 
               const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
 
diff --git a/tests/test_ItemValue.cpp b/tests/test_ItemValue.cpp
index 4271db6c25f21dc7aa7db61d93d9280a22aaf561..e5643274772843499826d487279f1003be2f1c4a 100644
--- a/tests/test_ItemValue.cpp
+++ b/tests/test_ItemValue.cpp
@@ -311,12 +311,12 @@ TEST_CASE("ItemValue", "[mesh]")
 
           const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
 
-          std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
+          std::array mesh_3d_list = MeshDataBaseForTests::get().all3DMeshes();
 
-          for (const auto& named_mesh : mesh_list) {
-            SECTION(named_mesh.name())
+          for (const auto& named_mesh_3d : mesh_3d_list) {
+            SECTION(named_mesh_3d.name())
             {
-              auto mesh_3d = named_mesh.mesh();
+              auto mesh_3d = named_mesh_3d.mesh();
 
               const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
 
diff --git a/tests/test_ListAffectationProcessor.cpp b/tests/test_ListAffectationProcessor.cpp
index 5910b3b4967acb846c11ff768ae4aa043772be57..73733b9833200f492c5e022ff1b727e57d104640 100644
--- a/tests/test_ListAffectationProcessor.cpp
+++ b/tests/test_ListAffectationProcessor.cpp
@@ -116,12 +116,6 @@ TEST_CASE("ListAffectationProcessor", "[language]")
 
   SECTION("lists with tuples affectation")
   {
-    auto stringify = [](auto&& value) {
-      std::ostringstream os;
-      os << std::boolalpha << value;
-      return os.str();
-    };
-
     SECTION("with (B)")
     {
       SECTION("from value")
diff --git a/tests/test_MathModule.cpp b/tests/test_MathModule.cpp
index 2cb3481b1e6cde7561733d8ea03decd46153db9d..f299d1e3678217d4fc6bcb4c08e417264b22a252 100644
--- a/tests/test_MathModule.cpp
+++ b/tests/test_MathModule.cpp
@@ -71,9 +71,9 @@ TEST_CASE("MathModule", "[language]")
       {
         arg = double{-3};
 
-        DataVariant arg_variant = arg;
+        DataVariant double_arg_variant = arg;
 
-        DataVariant result_variant = function_embedder.apply({arg_variant});
+        DataVariant result_variant = function_embedder.apply({double_arg_variant});
 
         auto result = std::abs(arg);
 
diff --git a/tests/test_ParallelChecker_read.cpp b/tests/test_ParallelChecker_read.cpp
index 497e1729d7ed719749327bcf652cf43a29ecaa4e..233d37e34d1b8b9069d918ade3657f07c3b3ba38 100644
--- a/tests/test_ParallelChecker_read.cpp
+++ b/tests/test_ParallelChecker_read.cpp
@@ -311,19 +311,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArray<double> arrays{connectivity, 1};
-        arrays.fill(0);
+        CellArray<double> double_cell_array{connectivity, 1};
+        double_cell_array.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
       }
 
       {
-        CellArray<double> arrays{connectivity, 2};
-        arrays.fill(0);
+        CellArray<double> double_cell_array{connectivity, 2};
+        double_cell_array.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -395,16 +395,16 @@ TEST_CASE("ParallelChecker_read", "[dev]")
         group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
           .write_raw<int>(&(numbers[0]));
 
-        Table<double> arrays{numbers.size(), 2};
+        Table<double> double_table{numbers.size(), 2};
         for (size_t i = 0; i < numbers.size(); ++i) {
           for (size_t j = 0; j < 2; ++j) {
-            arrays[i][j] = std::sin(2 * numbers[i] + j);
+            double_table[i][j] = std::sin(2 * numbers[i] + j);
           }
         }
         group
-          .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(),
-                                                                               arrays.numberOfColumns()}})
-          .write_raw<double>(&(arrays(0, 0)));
+          .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(),
+                                                                               double_table.numberOfColumns()}})
+          .write_raw<double>(&(double_table(0, 0)));
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -418,39 +418,39 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       ParallelCheckerTester pc_tester;
       pc_tester.setTag(tag);
 
-      CellArray<double> arrays{connectivity, 2};
+      CellArray<double> double_cell_array{connectivity, 2};
       CellValue<const int> cell_number = connectivity.cellNumber();
       for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
         for (size_t j = 0; j < 2; ++j) {
-          arrays[cell_id][j] = std::sin(2 * cell_number[cell_id] + j);
+          double_cell_array[cell_id][j] = std::sin(2 * cell_number[cell_id] + j);
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(double_cell_array, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_cell_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        CellArray<double> not_sync     = copy(arrays);
+        CellArray<double> not_sync     = copy(double_cell_array);
         CellValue<const bool> is_owned = connectivity.cellIsOwned();
         if (parallel::rank() == 0) {
           for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
@@ -467,7 +467,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArray<double> different = copy(arrays);
+        CellArray<double> different = copy(double_cell_array);
         bool has_difference         = false;
         if (parallel::rank() == 0) {
           CellValue<const bool> is_owned = connectivity.cellIsOwned();
@@ -495,11 +495,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArray<double> arrays{connectivity, 1};
-        arrays.fill(0);
+        CellArray<double> double_cell_array2{connectivity, 1};
+        double_cell_array2.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array2, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -630,21 +630,21 @@ TEST_CASE("ParallelChecker_read", "[dev]")
         group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
           .write_raw<int>(&(numbers[0]));
 
-        Table<DataType> arrays{numbers.size(), 2};
-        for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
-          for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+        Table<DataType> dt_table{numbers.size(), 2};
+        for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+          for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
             for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
               for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
-                arrays[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
+                dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
               }
             }
           }
         }
         group
           .createDataSet(name,
-                         HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+                         HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
                          test_TinyMatrixDataType<DataType>{})
-          .template write_raw<double>(&(arrays[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
+          .template write_raw<double>(&(dt_table[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -658,43 +658,43 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       ParallelCheckerTester pc_tester;
       pc_tester.setTag(tag);
 
-      FaceArray<DataType> arrays{connectivity, 2};
+      FaceArray<DataType> dt_face_array{connectivity, 2};
       FaceValue<const int> face_number = connectivity.faceNumber();
       for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-        for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+        for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
           for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
             for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
-              arrays[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
+              dt_face_array[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
             }
           }
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        FaceArray<DataType> not_sync   = copy(arrays);
+        FaceArray<DataType> not_sync   = copy(dt_face_array);
         FaceValue<const bool> is_owned = connectivity.faceIsOwned();
         if (parallel::rank() == 0) {
           for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -711,7 +711,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> different = copy(arrays);
+        FaceArray<DataType> different = copy(dt_face_array);
         bool has_difference           = false;
         if (parallel::rank() == 0) {
           FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -739,11 +739,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> arrays{connectivity, 1};
-        arrays.fill(zero);
+        FaceArray<DataType> dt_face_array2{connectivity, 1};
+        dt_face_array2.fill(zero);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -878,19 +878,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
         group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
           .write_raw<int>(&(numbers[0]));
 
-        Table<DataType> arrays{numbers.size(), 2};
-        for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
-          for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+        Table<DataType> dt_table{numbers.size(), 2};
+        for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+          for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
             for (size_t k = 0; k < DataType::Dimension; ++k) {
-              arrays[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
+              dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
             }
           }
         }
         group
           .createDataSet(name,
-                         HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+                         HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
                          test_TinyVectorDataType<DataType>{})
-          .template write_raw<double>(&(arrays[0][0][0]), test_TinyVectorDataType<DataType>{});
+          .template write_raw<double>(&(dt_table[0][0][0]), test_TinyVectorDataType<DataType>{});
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -904,41 +904,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       ParallelCheckerTester pc_tester;
       pc_tester.setTag(tag);
 
-      FaceArray<DataType> arrays{connectivity, 2};
+      FaceArray<DataType> dt_face_array{connectivity, 2};
       FaceValue<const int> face_number = connectivity.faceNumber();
       for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-        for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+        for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
           for (size_t k = 0; k < DataType::Dimension; ++k) {
-            arrays[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
+            dt_face_array[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
           }
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        FaceArray<DataType> not_sync   = copy(arrays);
+        FaceArray<DataType> not_sync   = copy(dt_face_array);
         FaceValue<const bool> is_owned = connectivity.faceIsOwned();
         if (parallel::rank() == 0) {
           for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -955,7 +955,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> different = copy(arrays);
+        FaceArray<DataType> different = copy(dt_face_array);
         bool has_difference           = false;
         if (parallel::rank() == 0) {
           FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -983,11 +983,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> arrays{connectivity, 1};
-        arrays.fill(zero);
+        FaceArray<DataType> dt_face_array2{connectivity, 1};
+        dt_face_array2.fill(zero);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -1135,11 +1135,12 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArrayPerNode<double> arrays{connectivity, 1};
-        arrays.fill(0);
+        CellArrayPerNode<double> double_cell_array_per_node{connectivity, 1};
+        double_cell_array_per_node.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array_per_node, "sin", source_location),
+                            "error: cannot compare data");
       }
 
       {
@@ -1235,19 +1236,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
                                                                                rows_map.size()}})
           .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0]));
 
-        Table<double> arrays{rows_map[rows_map.size() - 1], 2};
+        Table<double> double_table{rows_map[rows_map.size() - 1], 2};
         for (size_t i = 0; i < numbers.size(); ++i) {
           for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) {
             const size_t j = i_row - rows_map[i];
             for (size_t k = 0; k < 2; ++k) {
-              arrays[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
+              double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
             }
           }
         }
         group
-          .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(),
-                                                                               arrays.numberOfColumns()}})
-          .write_raw<double>(&(arrays(0, 0)));
+          .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(),
+                                                                               double_table.numberOfColumns()}})
+          .write_raw<double>(&(double_table(0, 0)));
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -1264,41 +1265,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
       auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
 
-      NodeArrayPerCell<double> arrays{connectivity, 2};
+      NodeArrayPerCell<double> double_node_array_per_cell{connectivity, 2};
       CellValue<const int> cell_number = connectivity.cellNumber();
       for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
         for (size_t j = 0; j < cell_to_node_matrix[cell_id].size(); ++j) {
           for (size_t k = 0; k < 2; ++k) {
-            arrays[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
+            double_node_array_per_cell[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
           }
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        NodeArrayPerCell<double> not_sync = copy(arrays);
+        NodeArrayPerCell<double> not_sync = copy(double_node_array_per_cell);
         CellValue<const bool> is_owned    = connectivity.cellIsOwned();
         if (parallel::rank() == 0) {
           for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
@@ -1315,7 +1316,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        NodeArrayPerCell<double> different = copy(arrays);
+        NodeArrayPerCell<double> different = copy(double_node_array_per_cell);
         bool has_difference                = false;
         if (parallel::rank() == 0) {
           CellValue<const bool> is_owned = connectivity.cellIsOwned();
@@ -1343,11 +1344,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArray<double> arrays{connectivity, 1};
-        arrays.fill(0);
+        CellArray<double> double_cell_array{connectivity, 1};
+        double_cell_array.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -1385,21 +1386,21 @@ TEST_CASE("ParallelChecker_read", "[dev]")
         group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
           .write_raw<int>(&(numbers[0]));
 
-        Table<DataType> arrays{numbers.size(), 2};
-        for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
-          for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+        Table<DataType> dt_table{numbers.size(), 2};
+        for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+          for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
             for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
               for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
-                arrays[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
+                dt_table[i][j](k, l) = std::sin(2 * numbers[i] + j + 3 * k + 2 * l);
               }
             }
           }
         }
         group
           .createDataSet(name,
-                         HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+                         HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
                          test_TinyMatrixDataType<DataType>{})
-          .template write_raw<double>(&(arrays[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
+          .template write_raw<double>(&(dt_table[0][0](0, 0)), test_TinyMatrixDataType<DataType>{});
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -1413,43 +1414,43 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       ParallelCheckerTester pc_tester;
       pc_tester.setTag(tag);
 
-      FaceArray<DataType> arrays{connectivity, 2};
+      FaceArray<DataType> dt_face_array{connectivity, 2};
       FaceValue<const int> face_number = connectivity.faceNumber();
       for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-        for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+        for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
           for (size_t k = 0; k < DataType::NumberOfRows; ++k) {
             for (size_t l = 0; l < DataType::NumberOfColumns; ++l) {
-              arrays[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
+              dt_face_array[face_id][j](k, l) = std::sin(2 * face_number[face_id] + j + 3 * k + 2 * l);
             }
           }
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        FaceArray<DataType> not_sync   = copy(arrays);
+        FaceArray<DataType> not_sync   = copy(dt_face_array);
         FaceValue<const bool> is_owned = connectivity.faceIsOwned();
         if (parallel::rank() == 0) {
           for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -1466,7 +1467,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> different = copy(arrays);
+        FaceArray<DataType> different = copy(dt_face_array);
         bool has_difference           = false;
         if (parallel::rank() == 0) {
           FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -1494,11 +1495,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> arrays{connectivity, 1};
-        arrays.fill(zero);
+        FaceArray<DataType> dt_face_array2{connectivity, 1};
+        dt_face_array2.fill(zero);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -1644,11 +1645,12 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArrayPerNode<double> arrays{connectivity, 1};
-        arrays.fill(0);
+        CellArrayPerNode<double> double_cell_array_per_node{connectivity, 1};
+        double_cell_array_per_node.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array_per_node, "sin", source_location),
+                            "error: cannot compare data");
       }
 
       {
@@ -1740,19 +1742,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
         group.createDataSet<int>("numbers", HighFive::DataSpace{std::vector<size_t>{numbers.size()}})
           .write_raw<int>(&(numbers[0]));
 
-        Table<DataType> arrays{numbers.size(), 2};
-        for (size_t i = 0; i < arrays.numberOfRows(); ++i) {
-          for (size_t j = 0; j < arrays.numberOfColumns(); ++j) {
+        Table<DataType> dt_table{numbers.size(), 2};
+        for (size_t i = 0; i < dt_table.numberOfRows(); ++i) {
+          for (size_t j = 0; j < dt_table.numberOfColumns(); ++j) {
             for (size_t k = 0; k < DataType::Dimension; ++k) {
-              arrays[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
+              dt_table[i][j][k] = std::sin(2 * numbers[i] + j + 3 * k);
             }
           }
         }
         group
           .createDataSet(name,
-                         HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(), arrays.numberOfColumns()}},
+                         HighFive::DataSpace{std::vector<size_t>{dt_table.numberOfRows(), dt_table.numberOfColumns()}},
                          test_TinyVectorDataType<DataType>{})
-          .template write_raw<double>(&(arrays[0][0][0]), test_TinyVectorDataType<DataType>{});
+          .template write_raw<double>(&(dt_table[0][0][0]), test_TinyVectorDataType<DataType>{});
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -1766,41 +1768,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       ParallelCheckerTester pc_tester;
       pc_tester.setTag(tag);
 
-      FaceArray<DataType> arrays{connectivity, 2};
+      FaceArray<DataType> dt_face_array{connectivity, 2};
       FaceValue<const int> face_number = connectivity.faceNumber();
       for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
-        for (size_t j = 0; j < arrays.sizeOfArrays(); ++j) {
+        for (size_t j = 0; j < dt_face_array.sizeOfArrays(); ++j) {
           for (size_t k = 0; k < DataType::Dimension; ++k) {
-            arrays[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
+            dt_face_array[face_id][j][k] = std::sin(2 * face_number[face_id] + j + 3 * k);
           }
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(dt_face_array, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        FaceArray<DataType> not_sync   = copy(arrays);
+        FaceArray<DataType> not_sync   = copy(dt_face_array);
         FaceValue<const bool> is_owned = connectivity.faceIsOwned();
         if (parallel::rank() == 0) {
           for (FaceId face_id = 0; face_id < connectivity.numberOfFaces(); ++face_id) {
@@ -1817,7 +1819,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> different = copy(arrays);
+        FaceArray<DataType> different = copy(dt_face_array);
         bool has_difference           = false;
         if (parallel::rank() == 0) {
           FaceValue<const bool> is_owned = connectivity.faceIsOwned();
@@ -1845,11 +1847,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        FaceArray<DataType> arrays{connectivity, 1};
-        arrays.fill(zero);
+        FaceArray<DataType> dt_face_array2{connectivity, 1};
+        dt_face_array2.fill(zero);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(dt_face_array2, "sin", source_location), "error: cannot compare data");
       }
 
       {
@@ -1890,19 +1892,19 @@ TEST_CASE("ParallelChecker_read", "[dev]")
                                                                                rows_map.size()}})
           .write_raw<typename ConnectivityMatrix::IndexType>(&(rows_map[0]));
 
-        Table<double> arrays{rows_map[rows_map.size() - 1], 2};
+        Table<double> double_table{rows_map[rows_map.size() - 1], 2};
         for (size_t i = 0; i < numbers.size(); ++i) {
           for (size_t i_row = rows_map[i]; i_row < rows_map[i + 1]; ++i_row) {
             const size_t j = i_row - rows_map[i];
             for (size_t k = 0; k < 2; ++k) {
-              arrays[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
+              double_table[i_row][k] = std::sin(2 * numbers[i] + (1 + k) * j);
             }
           }
         }
         group
-          .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{arrays.numberOfRows(),
-                                                                               arrays.numberOfColumns()}})
-          .write_raw<double>(&(arrays(0, 0)));
+          .createDataSet<double>(name, HighFive::DataSpace{std::vector<size_t>{double_table.numberOfRows(),
+                                                                               double_table.numberOfColumns()}})
+          .write_raw<double>(&(double_table(0, 0)));
 
         group.createAttribute("filename", source_location.filename());
         group.createAttribute("line", source_location.line());
@@ -1919,41 +1921,41 @@ TEST_CASE("ParallelChecker_read", "[dev]")
 
       auto cell_to_node_matrix = connectivity.cellToNodeMatrix();
 
-      NodeArrayPerCell<double> arrays{connectivity, 2};
+      NodeArrayPerCell<double> double_node_array_per_cell{connectivity, 2};
       CellValue<const int> cell_number = connectivity.cellNumber();
       for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
         for (size_t j = 0; j < cell_to_node_matrix[cell_id].size(); ++j) {
           for (size_t k = 0; k < 2; ++k) {
-            arrays[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
+            double_node_array_per_cell[cell_id][j][k] = std::sin(2 * cell_number[cell_id] + (1 + k) * j);
           }
         }
       }
 
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin", source_location));
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different name in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "not_sin", source_location));
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "not_sin", source_location));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source file in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
                                      SourceLocation{"other-source-file", source_location.line(),
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source line in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
                                      SourceLocation{source_location.filename(), source_location.line() + 100,
                                                     source_location.column(), source_location.function()}));
 
       pc_tester.setTag(tag);
       UNSCOPED_INFO("can have different source function in ref");
-      REQUIRE_NOTHROW(parallel_check(arrays, "sin",
+      REQUIRE_NOTHROW(parallel_check(double_node_array_per_cell, "sin",
                                      SourceLocation{source_location.filename(), source_location.line(),
                                                     source_location.column(), "foo"}));
 
       if (parallel::size() > 1) {
-        NodeArrayPerCell<double> not_sync = copy(arrays);
+        NodeArrayPerCell<double> not_sync = copy(double_node_array_per_cell);
         CellValue<const bool> is_owned    = connectivity.cellIsOwned();
         if (parallel::rank() == 0) {
           for (CellId cell_id = 0; cell_id < connectivity.numberOfCells(); ++cell_id) {
@@ -1970,7 +1972,7 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        NodeArrayPerCell<double> different = copy(arrays);
+        NodeArrayPerCell<double> different = copy(double_node_array_per_cell);
         bool has_difference                = false;
         if (parallel::rank() == 0) {
           CellValue<const bool> is_owned = connectivity.cellIsOwned();
@@ -1998,11 +2000,11 @@ TEST_CASE("ParallelChecker_read", "[dev]")
       }
 
       {
-        CellArray<double> arrays{connectivity, 1};
-        arrays.fill(0);
+        CellArray<double> double_cell_array{connectivity, 1};
+        double_cell_array.fill(0);
 
         pc_tester.setTag(tag);
-        REQUIRE_THROWS_WITH(parallel_check(arrays, "sin", source_location), "error: cannot compare data");
+        REQUIRE_THROWS_WITH(parallel_check(double_cell_array, "sin", source_location), "error: cannot compare data");
       }
 
       {
diff --git a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
index 39b5012700f9b8d8293829b4ccff65dad93036f6..f503eaac5865ac213c3140cae9b1afb9b30a33b7 100644
--- a/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToDiamondDualConnectivityDataMapper.cpp
@@ -105,11 +105,13 @@ TEST_CASE("PrimalToDiamondDualConnectivityDataMapper", "[mesh]")
 
         primal_to_dual_connectivity_mapper.toDualCell(primal_edge_value, dual_from_primal_edge_value);
 
-        bool is_same = true;
-        for (CellId cell_id = 0; cell_id < primal_connectivity.numberOfCells(); ++cell_id) {
-          is_same &= (dual_from_primal_edge_value[cell_id] == dual_from_primal_face_value[cell_id]);
+        {
+          bool is_same = true;
+          for (CellId cell_id = 0; cell_id < primal_connectivity.numberOfCells(); ++cell_id) {
+            is_same &= (dual_from_primal_edge_value[cell_id] == dual_from_primal_face_value[cell_id]);
+          }
+          REQUIRE(is_same);
         }
-        REQUIRE(is_same);
 
         {
           bool is_same = true;
diff --git a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
index 2950b0d40c9be3330aecc397e228b9e81bb08682..6a753b49fecf2b89f420b28f8c61411b01fe14df 100644
--- a/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
+++ b/tests/test_PrimalToMedianDualConnectivityDataMapper.cpp
@@ -178,13 +178,6 @@ TEST_CASE("PrimalToMedianDualConnectivityDataMapper", "[mesh]")
             primal_edge_value[edge_id] = 2 + (primal_edge_to_cell_matrix[edge_id].size() == 1);
           });
 
-        NodeValue<size_t> primal_node_value{primal_connectivity};
-        primal_node_value.fill(2);
-
-        NodeValue<size_t> dual_from_primal_value{dual_connectivity};
-        primal_to_dual_connectivity_mapper.toDualNode(primal_node_value, primal_edge_value, primal_cell_value,
-                                                      dual_from_primal_value);
-
         {
           const auto& dual_node_to_edge_matrix = dual_connectivity.nodeToEdgeMatrix();
           auto dual_node_number                = dual_connectivity.nodeNumber();
diff --git a/tests/test_SmallArray.cpp b/tests/test_SmallArray.cpp
index 2565ac0d7eb82beb828076840fda74d9b3ffbfa5..66191faa55c8890aae7901eacfe96cfd725da149 100644
--- a/tests/test_SmallArray.cpp
+++ b/tests/test_SmallArray.cpp
@@ -286,67 +286,67 @@ TEST_CASE("SmallArray", "[utils]")
 
   SECTION("checking for SmallArray reductions")
   {
-    SmallArray<int> a(10);
-    a[0] = 13;
-    a[1] = 1;
-    a[2] = 8;
-    a[3] = -3;
-    a[4] = 23;
-    a[5] = -1;
-    a[6] = 13;
-    a[7] = 0;
-    a[8] = 12;
-    a[9] = 9;
+    SmallArray<int> array(10);
+    array[0] = 13;
+    array[1] = 1;
+    array[2] = 8;
+    array[3] = -3;
+    array[4] = 23;
+    array[5] = -1;
+    array[6] = 13;
+    array[7] = 0;
+    array[8] = 12;
+    array[9] = 9;
 
     SECTION("Min")
     {
-      REQUIRE(min(a) == -3);
+      REQUIRE(min(array) == -3);
     }
 
     SECTION("Max")
     {
-      REQUIRE(max(a) == 23);
+      REQUIRE(max(array) == 23);
     }
 
     SECTION("Sum")
     {
-      REQUIRE((sum(a) == 75));
+      REQUIRE((sum(array) == 75));
     }
 
     SECTION("TinyVector Sum")
     {
       using N2 = TinyVector<2, int>;
-      SmallArray<N2> b(10);
-      b[0] = N2{13, 2};
-      b[1] = N2{1, 3};
-      b[2] = N2{8, -2};
-      b[3] = N2{-3, 2};
-      b[4] = N2{23, 4};
-      b[5] = N2{-1, -3};
-      b[6] = N2{13, 17};
-      b[7] = N2{0, 9};
-      b[8] = N2{12, 13};
-      b[9] = N2{9, -17};
-
-      REQUIRE((sum(b) == N2{75, 28}));
+      SmallArray<N2> N2_array(10);
+      N2_array[0] = N2{13, 2};
+      N2_array[1] = N2{1, 3};
+      N2_array[2] = N2{8, -2};
+      N2_array[3] = N2{-3, 2};
+      N2_array[4] = N2{23, 4};
+      N2_array[5] = N2{-1, -3};
+      N2_array[6] = N2{13, 17};
+      N2_array[7] = N2{0, 9};
+      N2_array[8] = N2{12, 13};
+      N2_array[9] = N2{9, -17};
+
+      REQUIRE((sum(N2_array) == N2{75, 28}));
     }
 
     SECTION("TinyMatrix Sum")
     {
       using N22 = TinyMatrix<2, 2, int>;
-      SmallArray<N22> b(10);
-      b[0] = N22{13, 2, 0, 1};
-      b[1] = N22{1, 3, 6, 3};
-      b[2] = N22{8, -2, -1, 21};
-      b[3] = N22{-3, 2, 5, 12};
-      b[4] = N22{23, 4, 7, 1};
-      b[5] = N22{-1, -3, 33, 11};
-      b[6] = N22{13, 17, 12, 13};
-      b[7] = N22{0, 9, 1, 14};
-      b[8] = N22{12, 13, -3, -71};
-      b[9] = N22{9, -17, 0, 16};
-
-      REQUIRE((sum(b) == N22{75, 28, 60, 21}));
+      SmallArray<N22> N22_array(10);
+      N22_array[0] = N22{13, 2, 0, 1};
+      N22_array[1] = N22{1, 3, 6, 3};
+      N22_array[2] = N22{8, -2, -1, 21};
+      N22_array[3] = N22{-3, 2, 5, 12};
+      N22_array[4] = N22{23, 4, 7, 1};
+      N22_array[5] = N22{-1, -3, 33, 11};
+      N22_array[6] = N22{13, 17, 12, 13};
+      N22_array[7] = N22{0, 9, 1, 14};
+      N22_array[8] = N22{12, 13, -3, -71};
+      N22_array[9] = N22{9, -17, 0, 16};
+
+      REQUIRE((sum(N22_array) == N22{75, 28, 60, 21}));
     }
   }
 #endif   // NDEBUG
diff --git a/tests/test_SmallMatrix.cpp b/tests/test_SmallMatrix.cpp
index 9712e13e330ee84adc55afeee1bcf81150312bc9..131b1e1f2fc4ae64622d410ac8e38ea051e9c9a7 100644
--- a/tests/test_SmallMatrix.cpp
+++ b/tests/test_SmallMatrix.cpp
@@ -364,53 +364,50 @@ TEST_CASE("SmallMatrix", "[algebra]")
 
   SECTION("output with signaling NaN")
   {
-    SmallMatrix<double> A(2, 3);
-    A(0, 0) = 1;
-    A(0, 2) = 3;
-    A(1, 0) = 2;
-    std::ostringstream A_ost;
-    A_ost << A;
+    SmallMatrix<double> C(2, 3);
+    C(0, 0) = 1;
+    C(0, 2) = 3;
+    C(1, 0) = 2;
+    std::ostringstream C_ost;
+    C_ost << C;
 
     std::ostringstream ref_ost;
     ref_ost << "0| 0:1 1:nan 2:3\n";
     ref_ost << "1| 0:2 1:nan 2:nan\n";
 
-    REQUIRE(A_ost.str() == ref_ost.str());
+    REQUIRE(C_ost.str() == ref_ost.str());
   }
 
-  // SECTION("checking for bounds violation")
-  // {
-  //   REQUIRE_THROWS_AS(A(3, 0), AssertError);
-  //   REQUIRE_THROWS_AS(A(0, 4), AssertError);
-
-  //   REQUIRE_THROWS_AS(getMinor(A, 3, 0), AssertError);
-  //   REQUIRE_THROWS_AS(getMinor(A, 0, 4), AssertError);
-
-  //   const TinyMatrix<3, 4, int>& constA = A;
-  //   REQUIRE_THROWS_AS(constA(3, 0), AssertError);
-  //   REQUIRE_THROWS_AS(constA(0, 4), AssertError);
-  // }
-
-  // SECTION("checking for nan initialization")
-  // {
-  //   TinyMatrix<3, 4, double> B;
-
-  //   for (size_t i = 0; i < B.numberOfRows(); ++i) {
-  //     for (size_t j = 0; j < B.numberOfColumns(); ++j) {
-  //       REQUIRE(std::isnan(B(i, j)));
-  //     }
-  //   }
-  // }
-
-  // SECTION("checking for bad initialization")
-  // {
-  //   TinyMatrix<3, 4, int> B;
-
-  //   for (size_t i = 0; i < B.numberOfRows(); ++i) {
-  //     for (size_t j = 0; j < B.numberOfColumns(); ++j) {
-  //       REQUIRE(B(i, j) == std::numeric_limits<int>::max() / 2);
-  //     }
-  //   }
-  // }
+  SECTION("checking for bounds violation")
+  {
+    REQUIRE_THROWS_AS(A(3, 0), AssertError);
+    REQUIRE_THROWS_AS(A(0, 4), AssertError);
+
+    const SmallMatrix<int>& constA = A;
+    REQUIRE_THROWS_AS(constA(3, 0), AssertError);
+    REQUIRE_THROWS_AS(constA(0, 4), AssertError);
+  }
+
+  SECTION("checking for nan initialization")
+  {
+    SmallMatrix<double> C(3, 4);
+
+    for (size_t i = 0; i < C.numberOfRows(); ++i) {
+      for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+        REQUIRE(std::isnan(C(i, j)));
+      }
+    }
+  }
+
+  SECTION("checking for bad initialization")
+  {
+    SmallMatrix<int> C(3, 5);
+
+    for (size_t i = 0; i < C.numberOfRows(); ++i) {
+      for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+        REQUIRE(C(i, j) == std::numeric_limits<int>::max() / 2);
+      }
+    }
+  }
 #endif   // NDEBUG
 }
diff --git a/tests/test_Socket.cpp b/tests/test_Socket.cpp
index 3293f6b8d7fe18db31a0db1aaac0ae30474d8808..a4ca9f6a4186e7edf326b433b80bbd2117ecdee9 100644
--- a/tests/test_Socket.cpp
+++ b/tests/test_Socket.cpp
@@ -29,10 +29,10 @@ TEST_CASE("Socket", "[utils]")
 
     Socket client = acceptClientSocket(server);
 
-    size_t vector_size = [&] {
-      size_t vector_size;
-      read(client, vector_size);
-      return vector_size;
+    const size_t vector_size = [&] {
+      size_t read_vector_size;
+      read(client, read_vector_size);
+      return read_vector_size;
     }();
 
     REQUIRE(vector_size == 4);
diff --git a/tests/test_TinyMatrix.cpp b/tests/test_TinyMatrix.cpp
index 03d3bbe5dc0ad69655cda5d3ae764d8e770b0d60..80159a021b54ebb162d339be2bbd5195aec815a0 100644
--- a/tests/test_TinyMatrix.cpp
+++ b/tests/test_TinyMatrix.cpp
@@ -173,18 +173,18 @@ TEST_CASE("TinyMatrix", "[algebra]")
 
   SECTION("checking for cofactors")
   {
-    TinyMatrix<3, 3, int> A(1, 2, 3, 4, 5, 6, 7, 8, 9);
-    REQUIRE(cofactor(A, 0, 0) == (5 * 9 - 8 * 6));
-    REQUIRE(cofactor(A, 1, 0) == -(2 * 9 - 8 * 3));
-    REQUIRE(cofactor(A, 2, 0) == (2 * 6 - 5 * 3));
-
-    REQUIRE(cofactor(A, 0, 1) == -(4 * 9 - 7 * 6));
-    REQUIRE(cofactor(A, 1, 1) == (1 * 9 - 7 * 3));
-    REQUIRE(cofactor(A, 2, 1) == -(1 * 6 - 4 * 3));
-
-    REQUIRE(cofactor(A, 0, 2) == (4 * 8 - 5 * 7));
-    REQUIRE(cofactor(A, 1, 2) == -(1 * 8 - 7 * 2));
-    REQUIRE(cofactor(A, 2, 2) == (1 * 5 - 4 * 2));
+    TinyMatrix<3, 3, int> square_A(1, 2, 3, 4, 5, 6, 7, 8, 9);
+    REQUIRE(cofactor(square_A, 0, 0) == (5 * 9 - 8 * 6));
+    REQUIRE(cofactor(square_A, 1, 0) == -(2 * 9 - 8 * 3));
+    REQUIRE(cofactor(square_A, 2, 0) == (2 * 6 - 5 * 3));
+
+    REQUIRE(cofactor(square_A, 0, 1) == -(4 * 9 - 7 * 6));
+    REQUIRE(cofactor(square_A, 1, 1) == (1 * 9 - 7 * 3));
+    REQUIRE(cofactor(square_A, 2, 1) == -(1 * 6 - 4 * 3));
+
+    REQUIRE(cofactor(square_A, 0, 2) == (4 * 8 - 5 * 7));
+    REQUIRE(cofactor(square_A, 1, 2) == -(1 * 8 - 7 * 2));
+    REQUIRE(cofactor(square_A, 2, 2) == (1 * 5 - 4 * 2));
   }
 
   SECTION("checking for determinant calculations")
@@ -294,17 +294,17 @@ TEST_CASE("TinyMatrix", "[algebra]")
 #ifndef NDEBUG
   SECTION("output with signaling NaN")
   {
-    TinyMatrix<2, 3> A;
-    A(0, 0) = 1;
-    A(0, 2) = 3;
-    A(1, 0) = 2;
-    std::ostringstream A_ost;
-    A_ost << A;
+    TinyMatrix<2, 3> C;
+    C(0, 0) = 1;
+    C(0, 2) = 3;
+    C(1, 0) = 2;
+    std::ostringstream C_ost;
+    C_ost << C;
 
     std::ostringstream ref_ost;
     ref_ost << "[[1,nan,3],[2,nan,nan]]";
 
-    REQUIRE(A_ost.str() == ref_ost.str());
+    REQUIRE(C_ost.str() == ref_ost.str());
   }
 
   SECTION("checking for bounds violation")
@@ -322,22 +322,22 @@ TEST_CASE("TinyMatrix", "[algebra]")
 
   SECTION("checking for nan initialization")
   {
-    TinyMatrix<3, 4, double> B;
+    TinyMatrix<3, 4, double> C;
 
-    for (size_t i = 0; i < B.numberOfRows(); ++i) {
-      for (size_t j = 0; j < B.numberOfColumns(); ++j) {
-        REQUIRE(std::isnan(B(i, j)));
+    for (size_t i = 0; i < C.numberOfRows(); ++i) {
+      for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+        REQUIRE(std::isnan(C(i, j)));
       }
     }
   }
 
   SECTION("checking for bad initialization")
   {
-    TinyMatrix<3, 4, int> B;
+    TinyMatrix<3, 4, int> C;
 
-    for (size_t i = 0; i < B.numberOfRows(); ++i) {
-      for (size_t j = 0; j < B.numberOfColumns(); ++j) {
-        REQUIRE(B(i, j) == std::numeric_limits<int>::max() / 2);
+    for (size_t i = 0; i < C.numberOfRows(); ++i) {
+      for (size_t j = 0; j < C.numberOfColumns(); ++j) {
+        REQUIRE(C(i, j) == std::numeric_limits<int>::max() / 2);
       }
     }
   }
diff --git a/tests/test_TinyVector.cpp b/tests/test_TinyVector.cpp
index 6a3942e84b1c95680d8c63080b5c8b37330f139b..12abadf46f3952ee8cceb8b4e9aa4b33c4ee88ed 100644
--- a/tests/test_TinyVector.cpp
+++ b/tests/test_TinyVector.cpp
@@ -89,33 +89,33 @@ TEST_CASE("TinyVector", "[algebra]")
 
   SECTION("min/max")
   {
-    TinyVector<5, int> u{1, 7, 6, 2, 9};
+    TinyVector<5, int> u1{1, 7, 6, 2, 9};
 
-    REQUIRE(min(u) == 1);
-    REQUIRE(max(u) == 9);
-    REQUIRE(min(-u) == -9);
-    REQUIRE(max(-u) == -1);
+    REQUIRE(min(u1) == 1);
+    REQUIRE(max(u1) == 9);
+    REQUIRE(min(-u1) == -9);
+    REQUIRE(max(-u1) == -1);
 
-    TinyVector<5, int> v{1, 11, 6, -2, 9};
+    TinyVector<5, int> u2{1, 11, 6, -2, 9};
 
-    REQUIRE(min(v) == -2);
-    REQUIRE(max(v) == 11);
-    REQUIRE(min(-v) == -11);
-    REQUIRE(max(-v) == 2);
+    REQUIRE(min(u2) == -2);
+    REQUIRE(max(u2) == 11);
+    REQUIRE(min(-u2) == -11);
+    REQUIRE(max(-u2) == 2);
   }
 
 #ifndef NDEBUG
   SECTION("output with signaling NaN")
   {
-    TinyVector<3> x;
-    x[1] = 1;
-    std::ostringstream x_ost;
-    x_ost << x;
+    TinyVector<3> X;
+    X[1] = 1;
+    std::ostringstream X_ost;
+    X_ost << X;
 
     std::ostringstream ref_ost;
     ref_ost << "[nan,1,nan]";
 
-    REQUIRE(x_ost.str() == ref_ost.str());
+    REQUIRE(X_ost.str() == ref_ost.str());
   }
 
   SECTION("checking for bounds validation")